System-on-a-Chip (SoC) Architecture for Low Power State Communication

ABSTRACT

An apparatus to facilitate a system-on-a-chip (SoC) architecture for low power state communication is disclosed. The apparatus includes a low power state fabric to provide a low power state path that avoids compute processing resources of the apparatus, and a low power state agent circuitry communicably coupled to the low power state fabric to update, in response to initiation of a low power state in the apparatus, a configuration of routers of the low power state fabric to utilize the low power state path provided by the low power state fabric, and to route memory transactions to the low power state path while the apparatus is in the low power state.

FIELD

This document relates generally to data processing and more particularlyto data processing via a general-purpose graphics processing unit.

BACKGROUND

Current parallel graphics data processing includes systems and methodsdeveloped to perform specific operations on graphics data such as, forexample, linear interpolation, tessellation, rasterization, texturemapping, depth testing, etc. Traditionally, graphics processors usedfixed function computational units to process graphics data. However,more recently, portions of graphics processors have been madeprogrammable, enabling such processors to support a wider variety ofoperations for processing vertex and fragment data.

To further increase performance, graphics processors typically implementprocessing techniques such as pipelining that attempt to process, inparallel, as much graphics data as possible throughout the differentparts of the graphics pipeline. Parallel graphics processors with singleinstruction, multiple thread (SIMT) architectures are designed tomaximize the amount of parallel processing in the graphics pipeline. Ina SIMT architecture, groups of parallel threads attempt to executeprogram instructions synchronously together as often as possible toincrease processing efficiency. A general overview of software andhardware for SIMT architectures can be found in Shane Cook, CUDAProgramming Chapter 3, pages 37-51 (2013).

Parallel rendering graphics architectures utilize a low power state orlow power mode to save and conserve energy. During low power states,components that are high-power consuming are put into a low power state.However, any attempts to transfer data through a component in a lowpower state wake the low power state components. When trying to debug asystem in a low power state to study failures in a memory subsystem,transferring data through the low power state components, such as aprocessing resource (including an EU or sub-slices containing EUs),changes the behavior of the system and hence, cannot debug the systemappropriately.

BRIEF DESCRIPTION OF THE DRAWINGS

So that the manner in which the features of the embodiments can beunderstood in detail, a more particular description of the embodiments,briefly summarized above, may be had by reference to embodiments, someof which are illustrated in the appended drawings. It is to be noted,however, that the appended drawings illustrate typical embodiments andare therefore not to be considered limiting of its scope.

FIG. 1 is a block diagram illustrating a computer system configured toimplement one or more aspects of the embodiments described herein;

FIG. 2A-2D illustrate parallel processor components;

FIG. 3A-3C are block diagrams of graphics multiprocessors andmultiprocessor-based GPUs;

FIG. 4A-4F illustrate an example architecture in which a plurality ofGPUs is communicatively coupled to a plurality of multi-core processors;

FIG. 5 illustrates a graphics processing pipeline;

FIG. 6 illustrates a machine learning software stack;

FIG. 7 illustrates a general-purpose graphics processing unit;

FIG. 8 illustrates a multi-GPU computing system;

FIG. 9A-9B illustrate layers of example deep neural networks;

FIG. 10 illustrates an example recurrent neural network;

FIG. 11 illustrates training and deployment of a deep neural network;

FIG. 12A is a block diagram illustrating distributed learning;

FIG. 12B is a block diagram illustrating a programmable networkinterface and data processing unit;

FIG. 13 illustrates an example inferencing system on a chip (SOC)suitable for performing inferencing using a trained model;

FIG. 14 is a block diagram of a processing system;

FIG. 15A-15C illustrate computing systems and graphics processors;

FIG. 16A-16C illustrate block diagrams of additional graphics processorand compute accelerator architectures;

FIG. 17 is a block diagram of a graphics processing engine of a graphicsprocessor;

FIG. 18A-18B illustrate thread execution logic including an array ofprocessing elements employed in a graphics processor core;

FIG. 19 illustrates an additional execution unit;

FIG. 20 is a block diagram illustrating a graphics processor instructionformats;

FIG. 21 is a block diagram of an additional graphics processorarchitecture;

FIG. 22A-22B illustrate a graphics processor command format and commandsequence;

FIG. 23 illustrates example graphics software architecture for a dataprocessing system;

FIG. 24A is a block diagram illustrating an IP core development system;

FIG. 24B illustrates a cross-section side view of an integrated circuitpackage assembly;

FIG. 24C illustrates a package assembly that includes multiple units ofhardware logic chiplets connected to a substrate (e.g., base die);

FIG. 24D illustrates a package assembly including interchangeablechiplets;

FIG. 25 is a block diagram illustrating an example system on a chipintegrated circuit;

FIG. 26A-26B are block diagrams illustrating example graphics processorsfor use within an SoC;

FIG. 27 is a block diagram illustrating an example SoC implementing anarchitecture for low power state communication, according to embodimentsherein.

FIG. 28 is a block diagram of a SoC architecture having a low powerstate agent in communication with a PSF, according to embodimentsherein.

FIG. 29 is a schematic illustrating implementation of low power statecommunications in an SoC architecture, in accordance with embodimentsherein.

FIG. 30 is a block diagram of a SoC architecture having a low powerstate agent in communication with a memory bridge fabric agent, which isin communication with a memory controller, in accordance withembodiments herein.

FIG. 31 is a flow diagram illustrating an embodiment of a method forimplementing an SoC architecture for low power state communication.

FIG. 32 is a flow diagram illustrating an embodiment of a method forentering a low power state and communicating in the low power stateusing an alternate low power state fabric path.

FIG. 33 is a flow diagram illustrating an embodiment of a method forexiting a low power state in an SoC architecture for low power statecommunications.

DETAILED DESCRIPTION

Implementations are directed to a system-on-a-chip (SoC) architecturefor low power state communication, such as in a graphics environmentincluding a graphics processing unit (GPU).

A graphics processing unit (GPU) is communicatively coupled tohost/processor cores to accelerate, for example, graphics operations,machine-learning operations, pattern analysis operations, and/or variousgeneral-purpose GPU (GPGPU) functions. The GPU may be communicativelycoupled to the host processor/cores over a bus or another interconnect(e.g., a high-speed interconnect such as PCIe or NVLink). Alternatively,the GPU may be integrated on the same package or chip as the cores andcommunicatively coupled to the cores over an internal processorbus/interconnect (i.e., internal to the package or chip). Regardless ofthe manner in which the GPU is connected, the processor cores mayallocate work to the GPU in the form of sequences ofcommands/instructions contained in a work descriptor. The GPU then usesdedicated circuitry/logic for efficiently processing thesecommands/instructions.

In the following description, numerous specific details are set forth toprovide a more thorough understanding. However, it can be apparent toone of skill in the art that the embodiments described herein may bepracticed without one or more of these specific details. In otherinstances, well-known features have not been described to avoidobscuring the details of the present embodiments.

System Overview

FIG. 1 is a block diagram illustrating a computing system 100 configuredto implement one or more aspects of the embodiments described herein.The computing system 100 includes a processing subsystem 101 having oneor more processor(s) 102 and a system memory 104 communicating via aninterconnection path that may include a memory hub 105. The memory hub105 may be a separate component within a chipset component or may beintegrated within the one or more processor(s) 102. The memory hub 105couples with an I/O subsystem 111 via a communication link 106. The I/Osubsystem 111 includes an I/O hub 107 that can enable the computingsystem 100 to receive input from one or more input device(s) 108.Additionally, the I/O hub 107 can enable a display controller, which maybe included in the one or more processor(s) 102, to provide outputs toone or more display device(s) 110A. In one embodiment the one or moredisplay device(s) 110A coupled with the I/O hub 107 can include a local,internal, or embedded display device.

The processing subsystem 101, for example, includes one or more parallelprocessor(s) 112 coupled to memory hub 105 via a bus or othercommunication link 113. The communication link 113 may be one of anynumber of standards-based communication link technologies or protocols,such as, but not limited to PCI Express, or may be a vendor specificcommunications interface or communications fabric. The one or moreparallel processor(s) 112 may form a computationally focused parallel orvector processing system that can include a large number of processingcores and/or processing clusters, such as a many integrated core (MIC)processor. For example, the one or more parallel processor(s) 112 form agraphics processing subsystem that can output pixels to one of the oneor more display device(s) 110A coupled via the I/O hub 107. The one ormore parallel processor(s) 112 can also include a display controller anddisplay interface (not shown) to enable a direct connection to one ormore display device(s) 110B.

Within the I/O subsystem 111, a system storage unit 114 can connect tothe I/O hub 107 to provide a storage mechanism for the computing system100. An I/O switch 116 can be used to provide an interface mechanism toenable connections between the I/O hub 107 and other components, such asa network adapter 118 and/or wireless network adapter 119 that may beintegrated into the platform, and various other devices that can beadded via one or more add-in device(s) 120. The add-in device(s) 120 mayalso include, for example, one or more external graphics processordevices, graphics cards, and/or compute accelerators. The networkadapter 118 can be an Ethernet adapter or another wired network adapter.The wireless network adapter 119 can include one or more of a Wi-Fi,Bluetooth, near field communication (NFC), or other network device thatincludes one or more wireless radios.

The computing system 100 can include other components not explicitlyshown, including USB or other port connections, optical storage drives,video capture devices, and the like, which may also be connected to theI/O hub 107. Communication paths interconnecting the various componentsin FIG. 1 may be implemented using any suitable protocols, such as PCI(Peripheral Component Interconnect) based protocols (e.g., PCI-Express),or any other bus or point-to-point communication interfaces and/orprotocol(s), such as the NVLink high-speed interconnect, Compute ExpressLink™ (CXL™) (e.g., CXL.mem), Infinity Fabric (IF), Ethernet (IEEE802.3), remote direct memory access (RDMA), InfiniBand, Internet WideArea RDMA Protocol (iWARP), Transmission Control Protocol (TCP), UserDatagram Protocol (UDP), quick UDP Internet Connections (QUIC), RDMAover Converged Ethernet (RoCE), Intel QuickPath Interconnect (QPI),Intel Ultra Path Interconnect (UPI), Intel On-Chip System Fabric (IOSF),Omnipath, HyperTransport, Advanced Microcontroller Bus Architecture(AMBA) interconnect, OpenCAPI, Gen-Z, Cache Coherent Interconnect forAccelerators (CCIX), 3GPP Long Term Evolution (LTE) (4G), 3GPP 5G, andvariations thereof, or wired or wireless interconnect protocols known inthe art. In some examples, data can be copied or stored to virtualizedstorage nodes using a protocol such as non-volatile memory express(NVMe) over Fabrics (NVMe-oF) or NVMe.

The one or more parallel processor(s) 112 may incorporate circuitryoptimized for graphics and video processing, including, for example,video output circuitry, and constitutes a graphics processing unit(GPU). Alternatively or additionally, the one or more parallelprocessor(s) 112 can incorporate circuitry optimized for general purposeprocessing, while preserving the underlying computational architecture,described in greater detail herein. Components of the computing system100 may be integrated with one or more other system elements on a singleintegrated circuit. For example, the one or more parallel processor(s)112, memory hub 105, processor(s) 102, and I/O hub 107 can be integratedinto a system on chip (SoC) integrated circuit. Alternatively, thecomponents of the computing system 100 can be integrated into a singlepackage to form a system in package (SIP) configuration. In oneembodiment at least a portion of the components of the computing system100 can be integrated into a multi-chip module (MCM), which can beinterconnected with other multi-chip modules into a modular computingsystem.

It can be appreciated that the computing system 100 shown herein isillustrative and that variations and modifications are possible. Theconnection topology, including the number and arrangement of bridges,the number of processor(s) 102, and the number of parallel processor(s)112, may be modified as desired. For instance, system memory 104 can beconnected to the processor(s) 102 directly rather than through a bridge,while other devices communicate with system memory 104 via the memoryhub 105 and the processor(s) 102. In other alternative topologies, theparallel processor(s) 112 are connected to the I/O hub 107 or directlyto one of the one or more processor(s) 102, rather than to the memoryhub 105. In other embodiments, the I/O hub 107 and memory hub 105 may beintegrated into a single chip. It is also possible that two or more setsof processor(s) 102 are attached via multiple sockets, which can couplewith two or more instances of the parallel processor(s) 112.

Some of the particular components shown herein are optional and may notbe included in all implementations of the computing system 100. Forexample, any number of add-in cards or peripherals may be supported, orsome components may be eliminated. Furthermore, some architectures mayuse different terminology for components similar to those illustrated inFIG. 1 . For example, the memory hub 105 may be referred to as aNorthbridge in some architectures, while the I/O hub 107 may be referredto as a Southbridge.

FIG. 2A illustrates a parallel processor 200. The parallel processor 200may be a GPU, GPGPU or the like as described herein. The variouscomponents of the parallel processor 200 may be implemented using one ormore integrated circuit devices, such as programmable processors,application specific integrated circuits (ASICs), or field programmablegate arrays (FPGA). The illustrated parallel processor 200 may be one ormore of the parallel processor(s) 112 shown in FIG. 1 .

The parallel processor 200 includes a parallel processing unit 202. Theparallel processing unit includes an I/O unit 204 that enablescommunication with other devices, including other instances of theparallel processing unit 202. The I/O unit 204 may be directly connectedto other devices. For instance, the I/O unit 204 connects with otherdevices via the use of a hub or switch interface, such as memory hub105. The connections between the memory hub 105 and the I/O unit 204form a communication link 113. Within the parallel processing unit 202,the I/O unit 204 connects with a host interface 206 and a memorycrossbar 216, where the host interface 206 receives commands directed toperforming processing operations and the memory crossbar 216 receivescommands directed to performing memory operations.

When the host interface 206 receives a command buffer via the I/O unit204, the host interface 206 can direct work operations to perform thosecommands to a front end 208. In one embodiment the front end 208 coupleswith a scheduler 210, which is configured to distribute commands orother work items to a processing cluster array 212. The scheduler 210ensures that the processing cluster array 212 is properly configured andin a valid state before tasks are distributed to the processing clustersof the processing cluster array 212. The scheduler 210 may beimplemented via firmware logic executing on a microcontroller. Themicrocontroller implemented scheduler 210 is configurable to performcomplex scheduling and work distribution operations at coarse and finegranularity, enabling rapid preemption and context switching of threadsexecuting on the processing cluster array 212. Preferably, the hostsoftware can prove workloads for scheduling on the processing clusterarray 212 via one of multiple graphics processing doorbells. In otherexamples, polling for new workloads or interrupts can be used toidentify or indicate availability of work to perform. The workloads canthen be automatically distributed across the processing cluster array212 by the scheduler 210 logic within the scheduler microcontroller.

The processing cluster array 212 can include up to “N” processingclusters (e.g., cluster 214A, cluster 214, through cluster 214N). Eachcluster 214A-214N of the processing cluster array 212 can execute alarge number of concurrent threads. The scheduler 210 can allocate workto the clusters 214A-214N of the processing cluster array 212 usingvarious scheduling and/or work distribution algorithms, which may varydepending on the workload arising for each type of program orcomputation. The scheduling can be handled dynamically by the scheduler210, or can be assisted in part by compiler logic during compilation ofprogram logic configured for execution by the processing cluster array212. Optionally, different clusters 214A-214N of the processing clusterarray 212 can be allocated for processing different types of programs orfor performing different types of computations.

The processing cluster array 212 can be configured to perform varioustypes of parallel processing operations. For example, the processingcluster array 212 is configured to perform general-purpose parallelcompute operations. For example, the processing cluster array 212 caninclude logic to execute processing tasks including filtering of videoand/or audio data, performing modeling operations, including physicsoperations, and performing data transformations.

The processing cluster array 212 is configured to perform parallelgraphics processing operations. In such embodiments in which theparallel processor 200 is configured to perform graphics processingoperations, the processing cluster array 212 can include additionallogic to support the execution of such graphics processing operations,including, but not limited to texture sampling logic to perform textureoperations, as well as tessellation logic and other vertex processinglogic. Additionally, the processing cluster array 212 can be configuredto execute graphics processing related shader programs such as, but notlimited to vertex shaders, tessellation shaders, geometry shaders, andpixel shaders. The parallel processing unit 202 can transfer data fromsystem memory via the I/O unit 204 for processing. During processing thetransferred data can be stored to on-chip memory (e.g., parallelprocessor memory 222) during processing, then written back to systemmemory.

In embodiments in which the parallel processing unit 202 is used toperform graphics processing, the scheduler 210 may be configured todivide the processing workload into approximately equal sized tasks, tobetter enable distribution of the graphics processing operations tomultiple clusters 214A-214N of the processing cluster array 212. In someof these embodiments, portions of the processing cluster array 212 canbe configured to perform different types of processing. For example, afirst portion may be configured to perform vertex shading and topologygeneration, a second portion may be configured to perform tessellationand geometry shading, and a third portion may be configured to performpixel shading or other screen space operations, to produce a renderedimage for display. Intermediate data produced by one or more of theclusters 214A-214N may be stored in buffers to allow the intermediatedata to be transmitted between clusters 214A-214N for furtherprocessing.

During operation, the processing cluster array 212 can receiveprocessing tasks to be executed via the scheduler 210, which receivescommands defining processing tasks from front end 208. For graphicsprocessing operations, processing tasks can include indices of data tobe processed, e.g., surface (patch) data, primitive data, vertex data,and/or pixel data, as well as state parameters and commands defining howthe data is to be processed (e.g., what program is to be executed). Thescheduler 210 may be configured to fetch the indices corresponding tothe tasks or may receive the indices from the front end 208. The frontend 208 can be configured to ensure the processing cluster array 212 isconfigured to a valid state before the workload specified by incomingcommand buffers (e.g., batch-buffers, push buffers, etc.) is initiated.

Each of the one or more instances of the parallel processing unit 202can couple with parallel processor memory 222. The parallel processormemory 222 can be accessed via the memory crossbar 216, which canreceive memory requests from the processing cluster array 212 as well asthe I/O unit 204. The memory crossbar 216 can access the parallelprocessor memory 222 via a memory interface 218. The memory interface218 can include multiple partition units (e.g., partition unit 220A,partition unit 220B, through partition unit 220N) that can each coupleto a portion (e.g., memory unit) of parallel processor memory 222. Thenumber of partition units 220A-220N may be configured to be equal to thenumber of memory units, such that a first partition unit 220A has acorresponding first memory unit 224A, a second partition unit 220B has acorresponding second memory unit 224B, and an Nth partition unit 220Nhas a corresponding Nth memory unit 224N. In other embodiments, thenumber of partition units 220A-220N may not be equal to the number ofmemory devices.

The memory units 224A-224N can include various types of memory devices,including dynamic random-access memory (DRAM) or graphics random accessmemory, such as synchronous graphics random access memory (SGRAM),including graphics double data rate (GDDR) memory. Optionally, thememory units 224A-224N may also include 3D stacked memory, including butnot limited to high bandwidth memory (HBM). Persons skilled in the artcan appreciate that the specific implementation of the memory units224A-224N can vary, and can be selected from one of various conventionaldesigns. Render targets, such as frame buffers or texture maps may bestored across the memory units 224A-224N, allowing partition units220A-220N to write portions of each render target in parallel toefficiently use the available bandwidth of parallel processor memory222. In some embodiments, a local instance of the parallel processormemory 222 may be excluded in favor of a unified memory design thatutilizes system memory in conjunction with local cache memory.

Optionally, any one of the clusters 214A-214N of the processing clusterarray 212 has the ability to process data that can be written to any ofthe memory units 224A-224N within parallel processor memory 222. Thememory crossbar 216 can be configured to transfer the output of eachcluster 214A-214N to any partition unit 220A-220N or to another cluster214A-214N, which can perform additional processing operations on theoutput. Each cluster 214A-214N can communicate with the memory interface218 through the memory crossbar 216 to read from or write to variousexternal memory devices. In one of the embodiments with the memorycrossbar 216 the memory crossbar 216 has a connection to the memoryinterface 218 to communicate with the I/O unit 204, as well as aconnection to a local instance of the parallel processor memory 222,enabling the processing units within the different processing clusters214A-214N to communicate with system memory or other memory that is notlocal to the parallel processing unit 202. Generally, the memorycrossbar 216 may, for example, be able to use virtual channels toseparate traffic streams between the clusters 214A-214N and thepartition units 220A-220N.

While a single instance of the parallel processing unit 202 isillustrated within the parallel processor 200, any number of instancesof the parallel processing unit 202 can be included. For example,multiple instances of the parallel processing unit 202 can be providedon a single add-in card, or multiple add-in cards can be interconnected.For example, the parallel processor 200 can be an add-in device, such asadd-in device 120 of FIG. 1 , which may be a graphics card such as adiscrete graphics card that includes one or more GPUs, one or morememory devices, and device-to-device or network or fabric interfaces.The different instances of the parallel processing unit 202 can beconfigured to inter-operate even if the different instances havedifferent numbers of processing cores, different amounts of localparallel processor memory, and/or other configuration differences.Optionally, some instances of the parallel processing unit 202 caninclude higher precision floating point units relative to otherinstances. Systems incorporating one or more instances of the parallelprocessing unit 202 or the parallel processor 200 can be implemented ina variety of configurations and form factors, including but not limitedto desktop, laptop, or handheld personal computers, servers,workstations, game consoles, and/or embedded systems. An orchestratorcan form composite nodes for workload performance using one or more of:disaggregated processor resources, cache resources, memory resources,storage resources, and networking resources.

FIG. 2B is a block diagram of a partition unit 220. The partition unit220 may be an instance of one of the partition units 220A-220N of FIG.2A. As illustrated, the partition unit 220 includes an L2 cache 221, aframe buffer interface 225, and a ROP 226 (raster operations unit). TheL2 cache 221 is a read/write cache that is configured to perform loadand store operations received from the memory crossbar 216 and ROP 226.Read misses and urgent write-back requests are output by L2 cache 221 toframe buffer interface 225 for processing. Updates can also be sent tothe frame buffer via the frame buffer interface 225 for processing. Inone embodiment the frame buffer interface 225 interfaces with one of thememory units in parallel processor memory, such as the memory units224A-224N of FIG. 2A (e.g., within parallel processor memory 222). Thepartition unit 220 may additionally or alternatively also interface withone of the memory units in parallel processor memory via a memorycontroller (not shown).

In graphics applications, the ROP 226 is a processing unit that performsraster operations such as stencil, z test, blending, and the like. TheROP 226 then outputs processed graphics data that is stored in graphicsmemory. In some embodiments the ROP 226 includes or couples with a CODEC227 that includes compression logic to compress depth or color data thatis written to memory or the L2 cache 221 and decompress depth or colordata that is read from memory or the L2 cache 221. The compression logiccan be lossless compression logic that makes use of one or more ofmultiple compression algorithms. The type of compression that isperformed by the CODEC 227 can vary based on the statisticalcharacteristics of the data to be compressed. For example, in oneembodiment, delta color compression is performed on depth and color dataon a per-tile basis. In one embodiment the CODEC 227 includescompression and decompression logic that can compress and decompresscompute data associated with machine learning operations. The CODEC 227can, for example, compress sparse matrix data for sparse machinelearning operations. The CODEC 227 can also compress sparse matrix datathat is encoded in a sparse matrix format (e.g., coordinate listencoding (COO), compressed sparse row (CSR), compress sparse column(CSC), etc.) to generate compressed and encoded sparse matrix data. Thecompressed and encoded sparse matrix data can be decompressed and/ordecoded before being processed by processing elements or the processingelements can be configured to consume compressed, encoded, or compressedand encoded data for processing.

The ROP 226 may be included within each processing cluster (e.g.,cluster 214A-214N of FIG. 2A) instead of within the partition unit 220.In such embodiment, read and write requests for pixel data aretransmitted over the memory crossbar 216 instead of pixel fragment data.The processed graphics data may be displayed on a display device, suchas one of the one or more display device(s) 110 of FIG. 1 , routed forfurther processing by the processor(s) 102, or routed for furtherprocessing by one of the processing entities within the parallelprocessor 200 of FIG. 2A.

FIG. 2C is a block diagram of a processing cluster 214 within a parallelprocessing unit. For example, the processing cluster is an instance ofone of the processing clusters 214A-214N of FIG. 2A. The processingcluster 214 can be configured to execute many threads in parallel, wherethe term “thread” refers to an instance of a particular programexecuting on a particular set of input data. Optionally,single-instruction, multiple-data (SIMD) instruction issue techniquesmay be used to support parallel execution of a large number of threadswithout providing multiple independent instruction units. Alternatively,single-instruction, multiple-thread (SIMT) techniques may be used tosupport parallel execution of a large number of generally synchronizedthreads, using a common instruction unit configured to issueinstructions to a set of processing engines within each one of theprocessing clusters. Unlike a SIMD execution regime, where allprocessing engines typically execute identical instructions, SIMTexecution allows different threads to more readily follow divergentexecution paths through a given thread program. Persons skilled in theart can understand that a SIMD processing regime represents a functionalsubset of a SIMT processing regime.

Operation of the processing cluster 214 can be controlled via a pipelinemanager 232 that distributes processing tasks to SIMT parallelprocessors. The pipeline manager 232 receives instructions from thescheduler 210 of FIG. 2A and manages execution of those instructions viaa graphics multiprocessor 234 and/or a texture unit 236. The illustratedgraphics multiprocessor 234 is an example instance of a SIMT parallelprocessor. However, various types of SIMT parallel processors ofdiffering architectures may be included within the processing cluster214. One or more instances of the graphics multiprocessor 234 can beincluded within a processing cluster 214. The graphics multiprocessor234 can process data and a data crossbar 240 can be used to distributethe processed data to one of multiple possible destinations, includingother shader units. The pipeline manager 232 can facilitate thedistribution of processed data by specifying destinations for processeddata to be distributed via the data crossbar 240.

Each graphics multiprocessor 234 within the processing cluster 214 caninclude an identical set of functional execution logic (e.g., arithmeticlogic units, load-store units, etc.). The functional execution logic canbe configured in a pipelined manner in which new instructions can beissued before previous instructions are complete. The functionalexecution logic supports a variety of operations including integer andfloating-point arithmetic, comparison operations, Boolean operations,bit-shifting, and computation of various algebraic functions. The samefunctional-unit hardware could be leveraged to perform differentoperations and any combination of functional units may be present.

The instructions transmitted to the processing cluster 214 constitute athread. A set of threads executing across the set of parallel processingengines is a thread group. A thread group executes the same program ondifferent input data. Each thread within a thread group can be assignedto a different processing engine within a graphics multiprocessor 234. Athread group may include fewer threads than the number of processingengines within the graphics multiprocessor 234. When a thread groupincludes fewer threads than the number of processing engines, one ormore of the processing engines may be idle during cycles in which thatthread group is being processed. A thread group may also include morethreads than the number of processing engines within the graphicsmultiprocessor 234. When the thread group includes more threads than thenumber of processing engines within the graphics multiprocessor 234,processing can be performed over consecutive clock cycles. Optionally,multiple thread groups can be executed concurrently on the graphicsmultiprocessor 234.

The graphics multiprocessor 234 may include an internal cache memory toperform load and store operations. Optionally, the graphicsmultiprocessor 234 can forego an internal cache and use a cache memory(e.g., level 1 (L1) cache 248) within the processing cluster 214. Eachgraphics multiprocessor 234 also has access to level 2 (L2) cacheswithin the partition units (e.g., partition units 220A-220N of FIG. 2A)that are shared among all processing clusters 214 and may be used totransfer data between threads. The graphics multiprocessor 234 may alsoaccess off-chip global memory, which can include one or more of localparallel processor memory and/or system memory. Any memory external tothe parallel processing unit 202 may be used as global memory.Embodiments in which the processing cluster 214 includes multipleinstances of the graphics multiprocessor 234 can share commoninstructions and data, which may be stored in the L1 cache 248.

Each processing cluster 214 may include an MMU 245 (memory managementunit) that is configured to map virtual addresses into physicaladdresses. In other embodiments, one or more instances of the MMU 245may reside within the memory interface 218 of FIG. 2A. The MMU 245includes a set of page table entries (PTEs) used to map a virtualaddress to a physical address of a tile and optionally a cache lineindex. The MMU 245 may include address translation lookaside buffers(TLB) or caches that may reside within the graphics multiprocessor 234or the L1 cache or processing cluster 214. The physical address isprocessed to distribute surface data access locality to allow efficientrequest interleaving among partition units. The cache line index may beused to determine whether a request for a cache line is a hit or miss.

In graphics and computing applications, a processing cluster 214 may beconfigured such that each graphics multiprocessor 234 is coupled to atexture unit 236 for performing texture mapping operations, e.g.,determining texture sample positions, reading texture data, andfiltering the texture data. Texture data is read from an internaltexture L1 cache (not shown) or in some embodiments from the L1 cachewithin graphics multiprocessor 234 and is fetched from an L2 cache,local parallel processor memory, or system memory. Each graphicsmultiprocessor 234 outputs processed tasks to the data crossbar 240 toprovide the processed task to another processing cluster 214 for furtherprocessing or to store the processed task in an L2 cache, local parallelprocessor memory, or system memory via the memory crossbar 216. A preROP242 (pre-raster operations unit) is configured to receive data fromgraphics multiprocessor 234, direct data to ROP units, which may belocated with partition units as described herein (e.g., partition units220A-220N of FIG. 2A). The preROP 242 unit can perform optimizations forcolor blending, organize pixel color data, and perform addresstranslations.

It can be appreciated that the core architecture described herein isillustrative and that variations and modifications are possible. Anynumber of processing units, e.g., graphics multiprocessor 234, textureunits 236, preROPs 242, etc., may be included within a processingcluster 214. Further, while one processing cluster 214 is shown, aparallel processing unit as described herein may include any number ofinstances of the processing cluster 214. Optionally, each processingcluster 214 can be configured to operate independently of otherprocessing clusters 214 using separate and distinct processing units, L1caches, L2 caches, etc.

FIG. 2D shows an example of the graphics multiprocessor 234 in which thegraphics multiprocessor 234 couples with the pipeline manager 232 of theprocessing cluster 214. The graphics multiprocessor 234 has an executionpipeline including but not limited to an instruction cache 252, aninstruction unit 254, an address mapping unit 256, a register file 258,one or more general purpose graphics processing unit (GPGPU) cores 262,and one or more load/store units 266. The GPGPU cores 262 and load/storeunits 266 are coupled with cache memory 272 and shared memory 270 via amemory and cache interconnect 268. The graphics multiprocessor 234 mayadditionally include tensor and/or ray-tracing cores 263 that includehardware logic to accelerate matrix and/or ray-tracing operations.

The instruction cache 252 may receive a stream of instructions toexecute from the pipeline manager 232. The instructions are cached inthe instruction cache 252 and dispatched for execution by theinstruction unit 254. The instruction unit 254 can dispatch instructionsas thread groups (e.g., warps), with each thread of the thread groupassigned to a different execution unit within GPGPU core 262. Aninstruction can access any of a local, shared, or global address spaceby specifying an address within a unified address space. The addressmapping unit 256 can be used to translate addresses in the unifiedaddress space into a distinct memory address that can be accessed by theload/store units 266.

The register file 258 provides a set of registers for the functionalunits of the graphics multiprocessor 234. The register file 258 providestemporary storage for operands connected to the data paths of thefunctional units (e.g., GPGPU cores 262, load/store units 266) of thegraphics multiprocessor 234. The register file 258 may be dividedbetween each of the functional units such that each functional unit isallocated a dedicated portion of the register file 258. For example, theregister file 258 may be divided between the different warps beingexecuted by the graphics multiprocessor 234.

The GPGPU cores 262 can each include floating point units (FPUs) and/orinteger arithmetic logic units (ALUs) that are used to executeinstructions of the graphics multiprocessor 234. In someimplementations, the GPGPU cores 262 can include hardware logic that mayotherwise reside within the tensor and/or ray-tracing cores 263. TheGPGPU cores 262 can be similar in architecture or can differ inarchitecture. For example and in one embodiment, a first portion of theGPGPU cores 262 include a single precision FPU and an integer ALU whilea second portion of the GPGPU cores include a double precision FPU.Optionally, the FPUs can implement the IEEE 754-2008 standard forfloating point arithmetic or enable variable precision floating pointarithmetic. The graphics multiprocessor 234 can additionally include oneor more fixed function or special function units to perform specificfunctions such as copy rectangle or pixel blending operations. One ormore of the GPGPU cores can also include fixed or special functionlogic.

The GPGPU cores 262 may include SIMD logic capable of performing asingle instruction on multiple sets of data. Optionally, GPGPU cores 262can physically execute SIMD4, SIMD8, and SIMD16 instructions andlogically execute SIMD1, SIMD2, and SIMD32 instructions. The SIMDinstructions for the GPGPU cores can be generated at compile time by ashader compiler or automatically generated when executing programswritten and compiled for single program multiple data (SPMD) or SIMTarchitectures. Multiple threads of a program configured for the SIMTexecution model can be executed via a single SIMD instruction. Forexample and in one embodiment, eight SIMT threads that perform the sameor similar operations can be executed in parallel via a single SIMD8logic unit.

The memory and cache interconnect 268 is an interconnect network thatconnects each of the functional units of the graphics multiprocessor 234to the register file 258 and to the shared memory 270. For example, thememory and cache interconnect 268 is a crossbar interconnect that allowsthe load/store unit 266 to implement load and store operations betweenthe shared memory 270 and the register file 258. The register file 258can operate at the same frequency as the GPGPU cores 262, thus datatransfer between the GPGPU cores 262 and the register file 258 is lowlatency. The shared memory 270 can be used to enable communicationbetween threads that execute on the functional units within the graphicsmultiprocessor 234. The cache memory 272 can be used as a data cache forexample, to cache texture data communicated between the functional unitsand the texture unit 236. The shared memory 270 can also be used as aprogram managed cached. The shared memory 270 and the cache memory 272can couple with the data crossbar 240 to enable communication with othercomponents of the processing cluster. Threads executing on the GPGPUcores 262 can programmatically store data within the shared memory inaddition to the automatically cached data that is stored within thecache memory 272.

FIG. 3A-3C illustrate additional graphics multiprocessors, according toembodiments. FIG. 3A-3B illustrate graphics multiprocessors 325, 350,which are related to the graphics multiprocessor 234 of FIG. 2C and maybe used in place of one of those. Therefore, the discussion of anyfeatures in combination with the graphics multiprocessor 234 herein alsodiscloses a corresponding combination with the graphicsmultiprocessor(s) 325, 350, but is not limited to such. FIG. 3Cillustrates a graphics processing unit (GPU) 380 which includesdedicated sets of graphics processing resources arranged into multi-coregroups 365A-365N, which correspond to the graphics multiprocessors 325,350. The illustrated graphics multiprocessors 325, 350 and themulti-core groups 365A-365N can be streaming multiprocessors (SM)capable of simultaneous execution of a large number of executionthreads.

The graphics multiprocessor 325 of FIG. 3A includes multiple additionalinstances of execution resource units relative to the graphicsmultiprocessor 234 of FIG. 2D. For example, the graphics multiprocessor325 can include multiple instances of the instruction unit 332A-332B,register file 334A-334B, and texture unit(s) 344A-344B. The graphicsmultiprocessor 325 also includes multiple sets of graphics or computeexecution units (e.g., GPGPU core 336A-336B, tensor core 337A-337B,ray-tracing core 338A-338B) and multiple sets of load/store units340A-340B. The execution resource units have a common instruction cache330, texture and/or data cache memory 342, and shared memory 346.

The various components can communicate via an interconnect fabric 327.The interconnect fabric 327 may include one or more crossbar switches toenable communication between the various components of the graphicsmultiprocessor 325. The interconnect fabric 327 may be a separate,high-speed network fabric layer upon which each component of thegraphics multiprocessor 325 is stacked. The components of the graphicsmultiprocessor 325 communicate with remote components via theinterconnect fabric 327. For example, the cores 336A-336B, 337A-337B,and 338A-338B can each communicate with shared memory 346 via theinterconnect fabric 327. The interconnect fabric 327 can arbitratecommunication within the graphics multiprocessor 325 to ensure a fairbandwidth allocation between components.

The graphics multiprocessor 350 of FIG. 3B includes multiple sets ofexecution resources 356A-356D, where each set of execution resourceincludes multiple instruction units, register files, GPGPU cores, andload store units, as illustrated in FIG. 2D and FIG. 3A. The executionresources 356A-356D can work in concert with texture unit(s) 360A-360Dfor texture operations, while sharing an instruction cache 354, andshared memory 353. For example, the execution resources 356A-356D canshare an instruction cache 354 and shared memory 353, as well asmultiple instances of a texture and/or data cache memory 358A-358B. Thevarious components can communicate via an interconnect fabric 352similar to the interconnect fabric 327 of FIG. 3A.

Persons skilled in the art can understand that the architecturedescribed in FIG. 1, 2A-2D, and 3A-3B are descriptive and not limitingas to the scope of the present embodiments. Thus, the techniquesdescribed herein may be implemented on any properly configuredprocessing unit, including, without limitation, one or more mobileapplication processors, one or more desktop or server central processingunits (CPUs) including multi-core CPUs, one or more parallel processingunits, such as the parallel processing unit 202 of FIG. 2A, as well asone or more graphics processors or special purpose processing units,without departure from the scope of the embodiments described herein.

The parallel processor or GPGPU as described herein may becommunicatively coupled to host/processor cores to accelerate graphicsoperations, machine-learning operations, pattern analysis operations,and various general-purpose GPU (GPGPU) functions. The GPU may becommunicatively coupled to the host processor/cores over a bus or otherinterconnect (e.g., a high-speed interconnect such as PCIe, NVLink, orother known protocols, standardized protocols, or proprietaryprotocols). In other embodiments, the GPU may be integrated on the samepackage or chip as the cores and communicatively coupled to the coresover an internal processor bus/interconnect (i.e., internal to thepackage or chip). Regardless of the manner in which the GPU isconnected, the processor cores may allocate work to the GPU in the formof sequences of commands/instructions contained in a work descriptor.The GPU then uses dedicated circuitry/logic for efficiently processingthese commands/instructions.

FIG. 3C illustrates a graphics processing unit (GPU) 380 which includesdedicated sets of graphics processing resources arranged into multi-coregroups 365A-365N. While the details of a single multi-core group 365Aare provided, it can be appreciated that the other multi-core groups365B-365N may be equipped with the same or similar sets of graphicsprocessing resources. Details described with respect to the multi-coregroups 365A-365N may also apply to any graphics multiprocessor 234, 325,350 described herein.

As illustrated, a multi-core group 365A may include a set of graphicscores 370, a set of tensor cores 371, and a set of ray tracing cores372. A scheduler/dispatcher 368 schedules and dispatches the graphicsthreads for execution on the various cores 370, 371, 372. A set ofregister files 369 store operand values used by the cores 370, 371, 372when executing the graphics threads. These may include, for example,integer registers for storing integer values, floating point registersfor storing floating point values, vector registers for storing packeddata elements (integer and/or floating-point data elements) and tileregisters for storing tensor/matrix values. The tile registers may beimplemented as combined sets of vector registers.

One or more combined level 1 (L1) caches and shared memory units 373store graphics data such as texture data, vertex data, pixel data, raydata, bounding volume data, etc., locally within each multi-core group365A. One or more texture units 374 can also be used to performtexturing operations, such as texture mapping and sampling. A Level 2(L2) cache 375 shared by all or a subset of the multi-core groups365A-365N stores graphics data and/or instructions for multipleconcurrent graphics threads. As illustrated, the L2 cache 375 may beshared across a plurality of multi-core groups 365A-365N. One or morememory controllers 367 couple the GPU 380 to a memory 366 which may be asystem memory (e.g., DRAM) and/or a dedicated graphics memory (e.g.,GDDR6 memory).

Input/output (I/O) circuitry 363 couples the GPU 380 to one or more I/Odevices 362 such as digital signal processors (DSPs), networkcontrollers, or user input devices. An on-chip interconnect may be usedto couple the I/O devices 362 to the GPU 380 and memory 366. One or moreI/O memory management units (IOMMUs) 364 of the I/O circuitry 363 couplethe I/O devices 362 directly to the system memory 366. Optionally, theIOMMU 364 manages multiple sets of page tables to map virtual addressesto physical addresses in system memory 366. The I/O devices 362, CPU(s)361, and GPU(s) 380 may then share the same virtual address space.

In one implementation of the IOMMU 364, the IOMMU 364 supportsvirtualization. In this case, it may manage a first set of page tablesto map guest/graphics virtual addresses to guest/graphics physicaladdresses and a second set of page tables to map the guest/graphicsphysical addresses to system/host physical addresses (e.g., withinsystem memory 366). The base addresses of each of the first and secondsets of page tables may be stored in control registers and swapped outon a context switch (e.g., so that the new context is provided withaccess to the relevant set of page tables). While not illustrated inFIG. 3C, each of the cores 370, 371, 372 and/or multi-core groups365A-365N may include translation lookaside buffers (TLBs) to cacheguest virtual to guest physical translations, guest physical to hostphysical translations, and guest virtual to host physical translations.

The CPU(s) 361, GPUs 380, and I/O devices 362 may be integrated on asingle semiconductor chip and/or chip package. The illustrated memory366 may be integrated on the same chip or may be coupled to the memorycontrollers 367 via an off-chip interface. In one implementation, thememory 366 comprises GDDR6 memory which shares the same virtual addressspace as other physical system-level memories, although the underlyingprinciples described herein are not limited to this specificimplementation.

The tensor cores 371 may include a plurality of execution unitsspecifically designed to perform matrix operations, which are the corecompute operation used to perform deep learning operations. For example,simultaneous matrix multiplication operations may be used for neuralnetwork training and inferencing. The tensor cores 371 may performmatrix processing using a variety of operand precisions including singleprecision floating-point (e.g., 32 bits), half-precision floating point(e.g., 16 bits), integer words (16 bits), bytes (8 bits), and half-bytes(4 bits). For example, a neural network implementation extracts featuresof each rendered scene, potentially combining details from multipleframes, to construct a high-quality final image.

In deep learning implementations, parallel matrix multiplication workmay be scheduled for execution on the tensor cores 371. The training ofneural networks, in particular, utilizes a significant number matrix dotproduct operations. In order to process an inner-product formulation ofan N×N×N matrix multiply, the tensor cores 371 may include at least Ndot-product processing elements. Before the matrix multiply begins, onematrix is loaded into tile registers and at least one column of a secondmatrix is loaded each cycle for N cycles. Each cycle, there are N dotproducts that are processed.

Matrix elements may be stored at different precisions depending on theparticular implementation, including 16-bit words, 8-bit bytes (e.g.,INT8) and 4-bit half-bytes (e.g., INT4). Different precision modes maybe specified for the tensor cores 371 to ensure that an efficientprecision is used for different workloads (e.g., such as inferencingworkloads which can tolerate quantization to bytes and half-bytes).Supported formats additionally include 64-bit floating point (FP64) andnon-IEEE floating point formats such as the bfloat16 format (e.g., Brainfloating point), a 16-bit floating point format with one sign bit, eightexponent bits, and eight significand bits, of which seven are explicitlystored. One embodiment includes support for a reduced precisiontensor-float format (TF32), which has the range of FP32 (8-bits) withthe precision of FP16 (10-bits). Reduced precision TF32 operations canbe performed on FP32 inputs and produce FP32 outputs at higherperformance relative to FP32 and increased precision relative to FP16.

In one embodiment the tensor cores 371 support a sparse mode ofoperation for matrices in which the vast majority of values are zero.The tensor cores 371 include support for sparse input matrices that areencoded in a sparse matrix representation (e.g., coordinate listencoding (COO), compressed sparse row (CSR), compress sparse column(CSC), etc.). The tensor cores 371 also include support for compressedsparse matrix representations in the event that the sparse matrixrepresentation may be further compressed. Compressed, encoded, and/orcompressed and encoded matrix data, along with associated compressionand/or encoding metadata, can be read by the tensor cores 371 and thenon-zero values can be extracted. For example, for a given input matrixA, a non-zero value can be loaded from the compressed and/or encodedrepresentation of at least a portion of matrix A. Based on the locationin matrix A for the non-zero value, which may be determined from indexor coordinate metadata associated with the non-zero value, acorresponding value in input matrix B may be loaded. Depending on theoperation to be performed (e.g., multiply), the load of the value frominput matrix B may be bypassed if the corresponding value is a zerovalue. In one embodiment, the pairings of values for one or moreoperations, such as multiply operations, may be pre-scanned by schedulerlogic and operations between non-zero inputs are scheduled. Depending onthe dimensions of matrix A and matrix B and the operation to beperformed, output matrix C may be dense or sparse. Where output matrix Cis sparse, and depending on the configuration of the tensor cores 371,output matrix C may be output in a compressed format, a sparse encoding,or a compressed sparse encoding.

The ray tracing cores 372 may accelerate ray tracing operations for bothreal-time ray tracing and non-real-time ray tracing implementations. Inparticular, the ray tracing cores 372 may include raytraversal/intersection circuitry for performing ray traversal usingbounding volume hierarchies (BVHs) and identifying intersections betweenrays and primitives enclosed within the BVH volumes. The ray tracingcores 372 may also include circuitry for performing depth testing andculling (e.g., using a Z buffer or similar arrangement). In oneimplementation, the ray tracing cores 372 perform traversal andintersection operations in concert with the image denoising techniquesdescribed herein, at least a portion of which may be executed on thetensor cores 371. For example, the tensor cores 371 may implement a deeplearning neural network to perform denoising of frames generated by theray tracing cores 372. However, the CPU(s) 361, graphics cores 370,and/or ray tracing cores 372 may also implement all or a portion of thedenoising and/or deep learning algorithms.

In addition, as described above, a distributed approach to denoising maybe employed in which the GPU 380 is in a computing device coupled toother computing devices over a network or high-speed interconnect. Inthis distributed approach, the interconnected computing devices mayshare neural network learning/training data to improve the speed withwhich the overall system learns to perform denoising for different typesof image frames and/or different graphics applications.

The ray tracing cores 372 may process all BVH traversal and/orray-primitive intersections, saving the graphics cores 370 from beingoverloaded with thousands of instructions per ray. For example, each raytracing core 372 includes a first set of specialized circuitry forperforming bounding box tests (e.g., for traversal operations) and/or asecond set of specialized circuitry for performing the ray-triangleintersection tests (e.g., intersecting rays which have been traversed).Thus, for example, the multi-core group 365A can simply launch a rayprobe, and the ray tracing cores 372 independently perform ray traversaland intersection and return hit data (e.g., a hit, no hit, multiplehits, etc.) to the thread context. The other cores 370, 371 are freed toperform other graphics or compute work while the ray tracing cores 372perform the traversal and intersection operations.

Optionally, each ray tracing core 372 may include a traversal unit toperform BVH testing operations and/or an intersection unit whichperforms ray-primitive intersection tests. The intersection unitgenerates a “hit”, “no hit”, or “multiple hit” response, which itprovides to the appropriate thread. During the traversal andintersection operations, the execution resources of the other cores(e.g., graphics cores 370 and tensor cores 371) are freed to performother forms of graphics work.

In one optional embodiment described below, a hybrid rasterization/raytracing approach is used in which work is distributed between thegraphics cores 370 and ray tracing cores 372.

The ray tracing cores 372 (and/or other cores 370, 371) may includehardware support for a ray tracing instruction set such as Microsoft'sDirectX Ray Tracing (DXR) which includes a DispatchRays command, as wellas ray-generation, closest-hit, any-hit, and miss shaders, which enablethe assignment of unique sets of shaders and textures for each object.Another ray tracing platform which may be supported by the ray tracingcores 372, graphics cores 370 and tensor cores 371 is Vulkan 1.1.85.Note, however, that the underlying principles described herein are notlimited to any particular ray tracing ISA.

In general, the various cores 372, 371, 370 may support a ray tracinginstruction set that includes instructions/functions for one or more ofray generation, closest hit, any hit, ray-primitive intersection,per-primitive and hierarchical bounding box construction, miss, visit,and exceptions. More specifically, an embodiment includes ray tracinginstructions to perform one or more of the following functions:

Ray Generation—Ray generation instructions may be executed for eachpixel, sample, or other user-defined work assignment.

Closest Hit—A closest hit instruction may be executed to locate theclosest intersection point of a ray with primitives within a scene.

Any Hit—An any hit instruction identifies multiple intersections betweena ray and primitives within a scene, potentially to identify a newclosest intersection point.

Intersection—An intersection instruction performs a ray-primitiveintersection test and outputs a result.

Per-primitive Bounding box Construction—This instruction builds abounding box around a given primitive or group of primitives (e.g., whenbuilding a new BVH or other acceleration data structure).

Miss—Indicates that a ray misses all geometry within a scene, orspecified region of a scene.

Visit—Indicates the children volumes a ray can traverse.

Exceptions—Includes various types of exception handlers (e.g., invokedfor various error conditions).

In one embodiment the ray tracing cores 372 may be adapted to accelerategeneral-purpose compute operations that can be accelerated usingcomputational techniques that are analogous to ray intersection tests. Acompute framework can be provided that enables shader programs to becompiled into low level instructions and/or primitives that performgeneral-purpose compute operations via the ray tracing cores. Examplecomputational problems that can benefit from compute operationsperformed on the ray tracing cores 372 include computations involvingbeam, wave, ray, or particle propagation within a coordinate space.Interactions associated with that propagation can be computed relativeto a geometry or mesh within the coordinate space. For example,computations associated with electromagnetic signal propagation throughan environment can be accelerated via the use of instructions orprimitives that are executed via the ray tracing cores. Diffraction andreflection of the signals by objects in the environment can be computedas direct ray-tracing analogies.

Ray tracing cores 372 can also be used to perform computations that arenot directly analogous to ray tracing. For example, mesh projection,mesh refinement, and volume sampling computations can be acceleratedusing the ray tracing cores 372. Generic coordinate space calculations,such as nearest neighbor calculations can also be performed. Forexample, the set of points near a given point can be discovered bydefining a bounding box in the coordinate space around the point. BVHand ray probe logic within the ray tracing cores 372 can then be used todetermine the set of point intersections within the bounding box. Theintersections constitute the origin point and the nearest neighbors tothat origin point. Computations that are performed using the ray tracingcores 372 can be performed in parallel with computations performed onthe graphics cores 372 and tensor cores 371. A shader compiler can beconfigured to compile a compute shader or other general-purpose graphicsprocessing program into low level primitives that can be parallelizedacross the graphics cores 370, tensor cores 371, and ray tracing cores372.

Techniques for GPU to Host Processor Interconnection

FIG. 4A illustrates an example architecture in which a plurality of GPUs410-413, e.g., such as the parallel processors 200 shown in FIG. 2A, arecommunicatively coupled to a plurality of multi-core processors 405-406over high-speed links 440A-440D (e.g., buses, point-to-pointinterconnects, etc.). The high-speed links 440A-440D may support acommunication throughput of 4 GB/s, 30 GB/s, 80 GB/s or higher,depending on the implementation. Various interconnect protocols may beused including, but not limited to, PCIe 4.0 or 5.0 and NVLink 2.0.However, the underlying principles described herein are not limited toany particular communication protocol or throughput.

Two or more of the GPUs 410-413 may be interconnected over high-speedlinks 442A-442B, which may be implemented using the same or differentprotocols/links than those used for high-speed links 440A-440D.Similarly, two or more of the multi-core processors 405-406 may beconnected over high speed link 443 which may be symmetricmulti-processor (SMP) buses operating at 20 GB/s, 30 GB/s, 120 GB/s orlower or higher speeds. Alternatively, all communication between thevarious system components shown in FIG. 4A may be accomplished using thesame protocols/links (e.g., over a common interconnection fabric). Asmentioned, however, the underlying principles described herein are notlimited to any particular type of interconnect technology.

Each multi-core processor 405-406 may be communicatively coupled to aprocessor memory 401-402, via memory interconnects 430A-430B,respectively, and each GPU 410-413 is communicatively coupled to GPUmemory 420-423 over GPU memory interconnects 450A-450D, respectively.The memory interconnects 430A-430B and 450A-450D may utilize the same ordifferent memory access technologies. By way of example, and notlimitation, the processor memories 401-402 and GPU memories 420-423 maybe volatile memories such as dynamic random-access memories (DRAMs)(including stacked DRAMs), Graphics DDR SDRAM (GDDR) (e.g., GDDR5,GDDR6), or High Bandwidth Memory (HBM) and/or may be non-volatilememories such as 3D XPoint/Optane or Nano-Ram. For example, some portionof the memories may be volatile memory and another portion may benon-volatile memory (e.g., using a two-level memory (2LM) hierarchy). Amemory subsystem as described herein may be compatible with a number ofmemory technologies, such as Double Data Rate versions released by JEDEC(Joint Electronic Device Engineering Council).

As described below, although the various processors 405-406 and GPUs410-413 may be physically coupled to a particular memory 401-402,420-423, respectively, a unified memory architecture may be implementedin which the same virtual system address space (also referred to as the“effective address” space) is distributed among all of the variousphysical memories. For example, processor memories 401-402 may eachcomprise 64 GB of the system memory address space and GPU memories420-423 may each comprise 32 GB of the system memory address space(resulting in a total of 256 GB addressable memory in this example).

FIG. 4B illustrates additional optional details for an interconnectionbetween a multi-core processor 407 and a graphics acceleration module446. The graphics acceleration module 446 may include one or more GPUchips integrated on a line card which is coupled to the processor 407via the high-speed link 440. Alternatively, the graphics accelerationmodule 446 may be integrated on the same package or chip as theprocessor 407.

The illustrated processor 407 includes a plurality of cores 460A-460D,each with a translation lookaside buffer 461A-461D and one or morecaches 462A-462D. The cores may include various other components forexecuting instructions and processing data which are not illustrated toavoid obscuring the underlying principles of the components describedherein (e.g., instruction fetch units, branch prediction units,decoders, execution units, reorder buffers, etc.). The caches 462A-462Dmay comprise level 1 (L1) and level 2 (L2) caches. In addition, one ormore shared caches 456 may be included in the caching hierarchy andshared by sets of the cores 460A-460D. For example, one embodiment ofthe processor 407 includes 24 cores, each with its own L1 cache, twelveshared L2 caches, and twelve shared L3 caches. In this embodiment, oneof the L2 and L3 caches are shared by two adjacent cores. The processor407 and the graphics accelerator integration module 446 connect withsystem memory 441, which may include processor memories 401-402.

Coherency is maintained for data and instructions stored in the variouscaches 462A-462D, 456 and system memory 441 via inter-core communicationover a coherence bus 464. For example, each cache may have cachecoherency logic/circuitry associated therewith to communicate to overthe coherence bus 464 in response to detected reads or writes toparticular cache lines. In one implementation, a cache snooping protocolis implemented over the coherence bus 464 to snoop cache accesses. Cachesnooping/coherency techniques are well understood by those of skill inthe art and cannot be described in detail here to avoid obscuring theunderlying principles described herein.

A proxy circuit 425 may be provided that communicatively couples thegraphics acceleration module 446 to the coherence bus 464, allowing thegraphics acceleration module 446 to participate in the cache coherenceprotocol as a peer of the cores. In particular, an interface 435provides connectivity to the proxy circuit 425 over high-speed link 440(e.g., a PCIe bus, NVLink, etc.) and an interface 437 connects thegraphics acceleration module 446 to the high-speed link 440.

In one implementation, an accelerator integration circuit 436 providescache management, memory access, context management, and interruptmanagement services on behalf of a plurality of graphics processingengines 431, 432, N of the graphics acceleration module 446. Thegraphics processing engines 431, 432, N may each comprise a separategraphics processing unit (GPU). Alternatively, the graphics processingengines 431, 432, N may comprise different types of graphics processingengines within a GPU such as graphics execution units, media processingengines (e.g., video encoders/decoders), samplers, and blit engines. Inother words, the graphics acceleration module may be a GPU with aplurality of graphics processing engines 431-432, N or the graphicsprocessing engines 431-432, N may be individual GPUs integrated on acommon package, line card, or chip.

The accelerator integration circuit 436 may include a memory managementunit (MMU) 439 for performing various memory management functions suchas virtual-to-physical memory translations (also referred to aseffective-to-real memory translations) and memory access protocols foraccessing system memory 441. The MMU 439 may also include a translationlookaside buffer (TLB) (not shown) for caching the virtual/effective tophysical/real address translations. In one implementation, a cache 438stores commands and data for efficient access by the graphics processingengines 431, 432, N. The data stored in cache 438 and graphics memories433-434, M may be kept coherent with the core caches 462A-462D, 456 andsystem memory 441. As mentioned, this may be accomplished via proxycircuit 425 which takes part in the cache coherency mechanism on behalfof cache 438 and memories 433-434, M (e.g., sending updates to the cache438 related to modifications/accesses of cache lines on processor caches462A-462D, 456 and receiving updates from the cache 438).

A set of registers 445 store context data for threads executed by thegraphics processing engines 431-432, N and a context management circuit448 manages the thread contexts. For example, the context managementcircuit 448 may perform save and restore operations to save and restorecontexts of the various threads during contexts switches (e.g., where afirst thread is saved and a second thread is restored so that the secondthread can be execute by a graphics processing engine). For example, ona context switch, the context management circuit 448 may store currentregister values to a designated region in memory (e.g., identified by acontext pointer). It may then restore the register values when returningto the context. An interrupt management circuit 447, for example, mayreceive and processes interrupts received from system devices.

In one implementation, virtual/effective addresses from a graphicsprocessing engine 431 are translated to real/physical addresses insystem memory 441 by the MMU 439. Optionally, the acceleratorintegration circuit 436 supports multiple (e.g., 4, 8, 16) graphicsaccelerator modules 446 and/or other accelerator devices. The graphicsaccelerator module 446 may be dedicated to a single application executedon the processor 407 or may be shared between multiple applications.Optionally, a virtualized graphics execution environment is provided inwhich the resources of the graphics processing engines 431-432, N areshared with multiple applications, virtual machines (VMs), orcontainers. The resources may be subdivided into “slices” which areallocated to different VMs and/or applications based on the processingrequirements and priorities associated with the VMs and/or applications.VMs and containers can be used interchangeably herein.

A virtual machine (VM) can be software that runs an operating system andone or more applications. A VM can be defined by specification,configuration files, virtual disk file, non-volatile random accessmemory (NVRAM) setting file, and the log file and is backed by thephysical resources of a host computing platform. A VM can include anoperating system (OS) or application environment that is installed onsoftware, which imitates dedicated hardware. The end user has the sameexperience on a virtual machine as they would have on dedicatedhardware. Specialized software, called a hypervisor, emulates the PCclient or server's CPU, memory, hard disk, network and other hardwareresources completely, enabling virtual machines to share the resources.The hypervisor can emulate multiple virtual hardware platforms that areisolated from each other, allowing virtual machines to run Linux®,Windows® Server, VMware ESXi, and other operating systems on the sameunderlying physical host.

A container can be a software package of applications, configurationsand dependencies so the applications run reliably on one computingenvironment to another. Containers can share an operating systeminstalled on the server platform and run as isolated processes. Acontainer can be a software package that contains components thesoftware utilizes to run such as system tools, libraries, and settings.Containers are not installed like traditional software programs, whichallows them to be isolated from the other software and the operatingsystem itself. The isolated nature of containers provides severalbenefits. First, the software in a container can run the same indifferent environments. For example, a container that includes PHP andMySQL can run identically on both a Linux® computer and a Windows®machine. Second, containers provide added security since the softwarecan not affect the host operating system. While an installed applicationmay alter system settings and modify resources, such as the Windowsregistry, a container can modify settings within the container.

Thus, the accelerator integration circuit 436 acts as a bridge to thesystem for the graphics acceleration module 446 and provides addresstranslation and system memory cache services. In one embodiment, tofacilitate the bridging functionality, the accelerator integrationcircuit 436 may also include shared I/O 497 (e.g., PCIe, USB, or others)and hardware to enable system control of voltage, clocking, performance,thermals, and security. The shared I/O 497 may utilize separate physicalconnections or may traverse the high-speed link 440. In addition, theaccelerator integration circuit 436 may provide virtualizationfacilities for the host processor to manage virtualization of thegraphics processing engines, interrupts, and memory management.

Because hardware resources of the graphics processing engines 431-432, Nare mapped explicitly to the real address space seen by the hostprocessor 407, any host processor can address these resources directlyusing an effective address value. One optional function of theaccelerator integration circuit 436 is the physical separation of thegraphics processing engines 431-432, N so that they appear to the systemas independent units.

One or more graphics memories 433-434, M may be coupled to each of thegraphics processing engines 431-432, N, respectively. The graphicsmemories 433-434, M store instructions and data being processed by eachof the graphics processing engines 431-432, N. The graphics memories433-434, M may be volatile memories such as DRAMs (including stackedDRAMs), GDDR memory (e.g., GDDR5, GDDR6), or HBM, and/or may benon-volatile memories such as 3D XPoint/Optane, Samsung Z-NAND, orNano-Ram.

To reduce data traffic over the high-speed link 440, biasing techniquesmay be used to ensure that the data stored in graphics memories 433-434,M is data which can be used frequently by the graphics processingengines 431-432, N and preferably not used by the cores 460A-460D (atleast not frequently). Similarly, the biasing mechanism attempts to keepdata utilized by the cores (and preferably not the graphics processingengines 431-432, N) within the caches 462A-462D, 456 of the cores andsystem memory 441.

According to a variant shown in FIG. 4C the accelerator integrationcircuit 436 is integrated within the processor 407. The graphicsprocessing engines 431-432, N communicate directly over the high-speedlink 440 to the accelerator integration circuit 436 via interface 437and interface 435 (which, again, may be utilize any form of bus orinterface protocol). The accelerator integration circuit 436 may performthe same operations as those described with respect to FIG. 4B, butpotentially at a higher throughput given its close proximity to thecoherence bus 464 and caches 462A-462D, 456.

The embodiments described may support different programming modelsincluding a dedicated-process programming model (no graphicsacceleration module virtualization) and shared programming models (withvirtualization). The latter may include programming models which arecontrolled by the accelerator integration circuit 436 and programmingmodels which are controlled by the graphics acceleration module 446.

In the embodiments of the dedicated process model, graphics processingengines 431, 432, . . . N may be dedicated to a single application orprocess under a single operating system. The single application canfunnel other application requests to the graphics engines 431, 432, . .. N, providing virtualization within a VM/partition.

In the dedicated-process programming models, the graphics processingengines 431,432, N, may be shared by multiple VM/application partitions.The shared models utilize a system hypervisor to virtualize the graphicsprocessing engines 431-432, N to allow access by each operating system.For single-partition systems without a hypervisor, the graphicsprocessing engines 431-432, N are owned by the operating system. In bothcases, the operating system can virtualize the graphics processingengines 431-432, N to provide access to each process or application.

For the shared programming model, the graphics acceleration module 446or an individual graphics processing engine 431-432, N selects a processelement using a process handle. The process elements may be stored insystem memory 441 and be addressable using the effective address to realaddress translation techniques described herein. The process handle maybe an implementation-specific value provided to the host process whenregistering its context with the graphics processing engine 431-432, N(that is, calling system software to add the process element to theprocess element linked list). The lower 16-bits of the process handlemay be the offset of the process element within the process elementlinked list.

FIG. 4D illustrates an example accelerator integration slice 490. Asused herein, a “slice” comprises a specified portion of the processingresources of the accelerator integration circuit 436. Applicationeffective address space 482 within system memory 441 stores processelements 483. The process elements 483 may be stored in response to GPUinvocations 481 from applications 480 executed on the processor 407. Aprocess element 483 contains the process state for the correspondingapplication 480. A work descriptor (WD) 484 contained in the processelement 483 can be a single job requested by an application or maycontain a pointer to a queue of jobs. In the latter case, the WD 484 isa pointer to the job request queue in the application's address space482.

The graphics acceleration module 446 and/or the individual graphicsprocessing engines 431-432, N can be shared by all or a subset of theprocesses in the system. For example, the technologies described hereinmay include an infrastructure for setting up the process state andsending a WD 484 to a graphics acceleration module 446 to start a job ina virtualized environment.

In one implementation, the dedicated-process programming model isimplementation-specific. In this model, a single process owns thegraphics acceleration module 446 or an individual graphics processingengine 431. Because the graphics acceleration module 446 is owned by asingle process, the hypervisor initializes the accelerator integrationcircuit 436 for the owning partition and the operating systeminitializes the accelerator integration circuit 436 for the owningprocess at the time when the graphics acceleration module 446 isassigned.

In operation, a WD fetch unit 491 in the accelerator integration slice490 fetches the next WD 484 which includes an indication of the work tobe done by one of the graphics processing engines of the graphicsacceleration module 446. Data from the WD 484 may be stored in registers445 and used by the MMU 439, interrupt management circuit 447 and/orcontext management circuit 448 as illustrated. For example, the MMU 439may include segment/page walk circuitry for accessing segment/pagetables 486 within the OS virtual address space 485. The interruptmanagement circuit 447 may process interrupt events 492 received fromthe graphics acceleration module 446. When performing graphicsoperations, an effective address 493 generated by a graphics processingengine 431-432, N is translated to a real address by the MMU 439.

The same set of registers 445 may be duplicated for each graphicsprocessing engine 431-432, N and/or graphics acceleration module 446 andmay be initialized by the hypervisor or operating system. Each of theseduplicated registers may be included in an accelerator integration slice490. In one embodiment, each graphics processing engine 431-432, N maybe presented to the hypervisor 496 as a distinct graphics processordevice. QoS settings can be configured for clients of a specificgraphics processing engine 431-432, N and data isolation between theclients of each engine can be enabled. Example registers that may beinitialized by the hypervisor are shown in Table 1.

TABLE 1 Hypervisor Initialized Registers 1 Slice Control Register 2 RealAddress (RA) Scheduled Processes Area Pointer 3 Authority Mask OverrideRegister 4 Interrupt Vector Table Entry Offset 5 Interrupt Vector TableEntry Limit 6 State Register 7 Logical Partition ID 8 Real address (RA)Hypervisor Accelerator Utilization Record Pointer 9 Storage DescriptionRegister

Example registers that may be initialized by the operating system areshown in Table 2.

TABLE 2 Operating System Initialized Registers 1 Process and ThreadIdentification 2 Effective Address (EA) Context Save/Restore Pointer 3Virtual Address (VA) Accelerator Utilization Record Pointer 4 VirtualAddress (VA) Storage Segment Table Pointer 5 Authority Mask 6 Workdescriptor

Each WD 484 may be specific to a particular graphics acceleration module446 and/or graphics processing engine 431-432, N. It contains all theinformation a graphics processing engine 431-432, N utilizes to do itswork or it can be a pointer to a memory location where the applicationhas set up a command queue of work to be completed.

FIG. 4E illustrates additional optional details of a shared model. Itincludes a hypervisor real address space 498 in which a process elementlist 499 is stored. The hypervisor real address space 498 is accessiblevia a hypervisor 496 which virtualizes the graphics acceleration moduleengines for the operating system 495.

The shared programming models allow for all or a subset of processesfrom all or a subset of partitions in the system to use a graphicsacceleration module 446. There are two programming models where thegraphics acceleration module 446 is shared by multiple processes andpartitions: time-sliced shared and graphics directed shared.

In this model, the system hypervisor 496 owns the graphics accelerationmodule 446 and makes its function available to all operating systems495. For a graphics acceleration module 446 to support virtualization bythe system hypervisor 496, the graphics acceleration module 446 mayadhere to the following requirements: 1) An application's job requestshould be autonomous (that is, the state does not have to be maintainedbetween jobs), or the graphics acceleration module 446 should provide acontext save and restore mechanism. 2) An application's job request isguaranteed by the graphics acceleration module 446 to complete in aspecified amount of time, including any translation faults, or thegraphics acceleration module 446 provides the ability to preempt theprocessing of the job. 3) The graphics acceleration module 446 should beguaranteed fairness between processes when operating in the directedshared programming model.

For the shared model, the application 480 may be utilized to make anoperating system 495 system call with a graphics acceleration module 446type, a work descriptor (WD), an authority mask register (AMR) value,and a context save/restore area pointer (CSRP). The graphicsacceleration module 446 type describes the targeted accelerationfunction for the system call. The graphics acceleration module 446 typemay be a system-specific value. The WD is formatted specifically for thegraphics acceleration module 446 and can be in the form of a graphicsacceleration module 446 command, an effective address pointer to auser-defined structure, an effective address pointer to a queue ofcommands, or any other data structure to describe the work to be done bythe graphics acceleration module 446. In one embodiment, the AMR valueis the AMR state to use for the current process. The value passed to theoperating system is similar to an application setting the AMR. If theaccelerator integration circuit 436 and graphics acceleration module 446implementations do not support a User Authority Mask Override Register(UAMOR), the operating system may apply the current UAMOR value to theAMR value before passing the AMR in the hypervisor call. The hypervisor496 may optionally apply the current Authority Mask Override Register(AMOR) value before placing the AMR into the process element 483. TheCSRP may be one of the registers 445 containing the effective address ofan area in the application's address space 482 for the graphicsacceleration module 446 to save and restore the context state. Thispointer is optional if no state is utilized to be saved between jobs orwhen a job is preempted. The context save/restore area may be pinnedsystem memory.

Upon receiving the system call, the operating system 495 may verify thatthe application 480 has registered and been given the authority to usethe graphics acceleration module 446. The operating system 495 thencalls the hypervisor 496 with the information shown in Table 3.

TABLE 3 OS to Hypervisor Call Parameters 1 A work descriptor (WD) 2 AnAuthority Mask Register (AMR) value (potentially masked). 3 An effectiveaddress (EA) Context Save/Restore Area Pointer (CSRP) 4 A process ID(PID) and optional thread ID (TID) 5 A virtual address (VA) acceleratorutilization record pointer (AURP) 6 The virtual address of the storagesegment table pointer (SSTP) 7 A logical interrupt service number (LISN)

Upon receiving the hypervisor call, the hypervisor 496 verifies that theoperating system 495 has registered and been given the authority to usethe graphics acceleration module 446. The hypervisor 496 then puts theprocess element 483 into the process element linked list for thecorresponding graphics acceleration module 446 type. The process elementmay include the information shown in Table 4.

TABLE 4 Process Element Information  1 A work descriptor (WD)  2 AnAuthority Mask Register (AMR) value (potentially masked).  3 Aneffective address (EA) Context Save/ Restore Area Pointer (CSRP)  4 Aprocess ID (PID) and optional thread ID (TID)  5 A virtual address (VA)accelerator utilization record pointer (AURP)  6 The virtual address ofthe storage segment table pointer (SSTP)  7 A logical interrupt servicenumber (LISN)  8 Interrupt vector table, derived from the hypervisorcall parameters.  9 A state register (SR) value 10 A logical partitionID (LPID) 11 A real address (RA) hypervisor accelerator utilizationrecord pointer 12 The Storage Descriptor Register (SDR)

The hypervisor may initialize a plurality of accelerator integrationslice 490 registers 445.

As illustrated in FIG. 4F, in one optional implementation a unifiedmemory addressable via a common virtual memory address space used toaccess the physical processor memories 401-402 and GPU memories 420-423is employed. In this implementation, operations executed on the GPUs410-413 utilize the same virtual/effective memory address space toaccess the processors memories 401-402 and vice versa, therebysimplifying programmability. A first portion of the virtual/effectiveaddress space may be allocated to the processor memory 401, a secondportion to the second processor memory 402, a third portion to the GPUmemory 420, and so on. The virtual/effective memory space (sometimesreferred to as the effective address space) may thereby be distributedacross each of the processor memories 401-402 and GPU memories 420-423,allowing any processor or GPU to access any physical memory with avirtual address mapped to that memory.

Bias/coherence management circuitry 494A-494E within one or more of theMMUs 439A-439E may be provided that ensures cache coherence between thecaches of the host processors (e.g., 405) and the GPUs 410-413 andimplements biasing techniques indicating the physical memories in whichone or more types of data should be stored. While multiple instances ofbias/coherence management circuitry 494A-494E are illustrated in FIG.4F, the bias/coherence circuitry may be implemented within the MMU ofone or more host processors 405 and/or within the acceleratorintegration circuit 436.

The GPU-attached memory 420-423 may be mapped as part of system memory,and accessed using shared virtual memory (SVM) technology, but withoutsuffering the typical performance drawbacks associated with full systemcache coherence. The ability to GPU-attached memory 420-423 to beaccessed as system memory without onerous cache coherence overheadprovides a beneficial operating environment for GPU offload. Thisarrangement allows the host processor 405 software to setup operands andaccess computation results, without the overhead of tradition I/O DMAdata copies. Such traditional copies involve driver calls, interruptsand memory mapped I/O (MMIO) accesses that are all inefficient relativeto simple memory accesses. At the same time, the ability to access GPUattached memory 420-423 without cache coherence overheads can becontributory to the execution time of an offloaded computation. In caseswith substantial streaming write memory traffic, for example, cachecoherence overhead can significantly reduce the effective writebandwidth seen by a GPU 410-413. The efficiency of operand setup, theefficiency of results access, and the efficiency of GPU computation allplay a role in determining the effectiveness of GPU offload.

A selection between GPU bias and host processor bias may be driven by abias tracker data structure. A bias table may be used, for example,which may be a page-granular structure (i.e., controlled at thegranularity of a memory page) that includes 1 or 2 bits per GPU-attachedmemory page. The bias table may be implemented in a stolen memory rangeof one or more GPU-attached memories 420-423, with or without a biascache in the GPU 410-413 (e.g., to cache frequently/recently usedentries of the bias table). Alternatively, the bias table may bemaintained within the GPU.

In one implementation, the bias table entry associated with each accessto the GPU-attached memory 420-423 is accessed prior the actual accessto the GPU memory, causing the following operations. First, localrequests from the GPU 410-413 that find their page in GPU bias areforwarded directly to a corresponding GPU memory 420-423. Local requestsfrom the GPU that find their page in host bias are forwarded to theprocessor 405 (e.g., over a high-speed link as discussed above).Optionally, requests from the processor 405 that find the requested pagein host processor bias complete the request like a normal memory read.Alternatively, requests directed to a GPU-biased page may be forwardedto the GPU 410-413. The GPU may then transition the page to a hostprocessor bias if it is not currently using the page.

The bias state of a page can be changed either by a software-basedmechanism, a hardware-assisted software-based mechanism, or, for alimited set of cases, a purely hardware-based mechanism.

One mechanism for changing the bias state employs an API call (e.g.,OpenCL), which, in turn, calls the GPU's device driver which, in turn,sends a message (or enqueues a command descriptor) to the GPU directingit to change the bias state and, for some transitions, perform a cacheflushing operation in the host. The cache flushing operation is utilizedfor a transition from host processor 405 bias to GPU bias, but is notutilized for the opposite transition.

Cache coherency may be maintained by temporarily rendering GPU-biasedpages uncacheable by the host processor 405. To access these pages, theprocessor 405 may request access from the GPU 410 which may or may notgrant access right away, depending on the implementation. Thus, toreduce communication between the host processor 405 and GPU 410 it isbeneficial to ensure that GPU-biased pages are those which are utilizedby the GPU but not the host processor 405 and vice versa.

Graphics Processing Pipeline

FIG. 5 illustrates a graphics processing pipeline 500. A graphicsmultiprocessor, such as graphics multiprocessor 234 as in FIG. 2D,graphics multiprocessor 325 of FIG. 3A, graphics multiprocessor 350 ofFIG. 3B can implement the illustrated graphics processing pipeline 500.The graphics multiprocessor can be included within the parallelprocessing subsystems as described herein, such as the parallelprocessor 200 of FIG. 2A, which may be related to the parallelprocessor(s) 112 of FIG. 1 and may be used in place of one of those. Thevarious parallel processing systems can implement the graphicsprocessing pipeline 500 via one or more instances of the parallelprocessing unit (e.g., parallel processing unit 202 of FIG. 2A) asdescribed herein. For example, a shader unit (e.g., graphicsmultiprocessor 234 of FIG. 2C) may be configured to perform thefunctions of one or more of a vertex processing unit 504, a tessellationcontrol processing unit 508, a tessellation evaluation processing unit512, a geometry processing unit 516, and a fragment/pixel processingunit 524. The functions of data assembler 502, primitive assemblers 506,514, 518, tessellation unit 510, rasterizer 522, and raster operationsunit 526 may also be performed by other processing engines within aprocessing cluster (e.g., processing cluster 214 of FIG. 2A) and acorresponding partition unit (e.g., partition unit 220A-220N of FIG.2A). The graphics processing pipeline 500 may also be implemented usingdedicated processing units for one or more functions. It is alsopossible that one or more portions of the graphics processing pipeline500 are performed by parallel processing logic within a general-purposeprocessor (e.g., CPU). Optionally, one or more portions of the graphicsprocessing pipeline 500 can access on-chip memory (e.g., parallelprocessor memory 222 as in FIG. 2A) via a memory interface 528, whichmay be an instance of the memory interface 218 of FIG. 2A. The graphicsprocessor pipeline 500 may also be implemented via a multi-core group365A as in FIG. 3C.

The data assembler 502 is a processing unit that may collect vertex datafor surfaces and primitives. The data assembler 502 then outputs thevertex data, including the vertex attributes, to the vertex processingunit 504. The vertex processing unit 504 is a programmable executionunit that executes vertex shader programs, lighting and transformingvertex data as specified by the vertex shader programs. The vertexprocessing unit 504 reads data that is stored in cache, local or systemmemory for use in processing the vertex data and may be programmed totransform the vertex data from an object-based coordinate representationto a world space coordinate space or a normalized device coordinatespace.

A first instance of a primitive assembler 506 receives vertex attributesfrom the vertex processing unit 504. The primitive assembler 506readings stored vertex attributes and constructs graphics primitives forprocessing by tessellation control processing unit 508. The graphicsprimitives include triangles, line segments, points, patches, and soforth, as supported by various graphics processing applicationprogramming interfaces (APIs).

The tessellation control processing unit 508 treats the input verticesas control points for a geometric patch. The control points aretransformed from an input representation from the patch (e.g., thepatch's bases) to a representation that is suitable for use in surfaceevaluation by the tessellation evaluation processing unit 512. Thetessellation control processing unit 508 can also compute tessellationfactors for edges of geometric patches. A tessellation factor applies toa single edge and quantifies a view-dependent level of detail associatedwith the edge. A tessellation unit 510 is configured to receive thetessellation factors for edges of a patch and to tessellate the patchinto multiple geometric primitives such as line, triangle, orquadrilateral primitives, which are transmitted to a tessellationevaluation processing unit 512. The tessellation evaluation processingunit 512 operates on parameterized coordinates of the subdivided patchto generate a surface representation and vertex attributes for eachvertex associated with the geometric primitives.

A second instance of a primitive assembler 514 receives vertexattributes from the tessellation evaluation processing unit 512, readingstored vertex attributes, and constructs graphics primitives forprocessing by the geometry processing unit 516. The geometry processingunit 516 is a programmable execution unit that executes geometry shaderprograms to transform graphics primitives received from primitiveassembler 514 as specified by the geometry shader programs. The geometryprocessing unit 516 may be programmed to subdivide the graphicsprimitives into one or more new graphics primitives and calculateparameters used to rasterize the new graphics primitives.

The geometry processing unit 516 may be able to add or delete elementsin the geometry stream. The geometry processing unit 516 outputs theparameters and vertices specifying new graphics primitives to primitiveassembler 518. The primitive assembler 518 receives the parameters andvertices from the geometry processing unit 516 and constructs graphicsprimitives for processing by a viewport scale, cull, and clip unit 520.The geometry processing unit 516 reads data that is stored in parallelprocessor memory or system memory for use in processing the geometrydata. The viewport scale, cull, and clip unit 520 performs clipping,culling, and viewport scaling and outputs processed graphics primitivesto a rasterizer 522.

The rasterizer 522 can perform depth culling and other depth-basedoptimizations. The rasterizer 522 also performs scan conversion on thenew graphics primitives to generate fragments and output those fragmentsand associated coverage data to the fragment/pixel processing unit 524.The fragment/pixel processing unit 524 is a programmable execution unitthat is configured to execute fragment shader programs or pixel shaderprograms. The fragment/pixel processing unit 524 transforming fragmentsor pixels received from rasterizer 522, as specified by the fragment orpixel shader programs. For example, the fragment/pixel processing unit524 may be programmed to perform operations included but not limited totexture mapping, shading, blending, texture correction and perspectivecorrection to produce shaded fragments or pixels that are output to araster operations unit 526. The fragment/pixel processing unit 524 canread data that is stored in either the parallel processor memory or thesystem memory for use when processing the fragment data. Fragment orpixel shader programs may be configured to shade at sample, pixel, tile,or other granularities depending on the sampling rate configured for theprocessing units.

The raster operations unit 526 is a processing unit that performs rasteroperations including, but not limited to stencil, z-test, blending, andthe like, and outputs pixel data as processed graphics data to be storedin graphics memory (e.g., parallel processor memory 222 as in FIG. 2A,and/or system memory 104 as in FIG. 1 ), to be displayed on the one ormore display device(s) 110 or for further processing by one of the oneor more processor(s) 102 or parallel processor(s) 112. The rasteroperations unit 526 may be configured to compress z or color data thatis written to memory and decompress z or color data that is read frommemory.

Machine Learning Overview

The architecture described above can be applied to perform training andinference operations using machine learning models. Machine learning hasbeen successful at solving many kinds of tasks. The computations thatarise when training and using machine learning algorithms (e.g., neuralnetworks) lend themselves naturally to efficient parallelimplementations. Accordingly, parallel processors such asgeneral-purpose graphics processing units (GPGPUs) have played asignificant role in the practical implementation of deep neuralnetworks. Parallel graphics processors with single instruction, multiplethread (SIMT) architectures are designed to maximize the amount ofparallel processing in the graphics pipeline. In an SIMT architecture,groups of parallel threads attempt to execute program instructionssynchronously together as often as possible to increase processingefficiency. The efficiency provided by parallel machine learningalgorithm implementations allows the use of high capacity networks andenables those networks to be trained on larger datasets.

A machine learning algorithm is an algorithm that can learn based on aset of data. For example, machine learning algorithms can be designed tomodel high-level abstractions within a data set. For example, imagerecognition algorithms can be used to determine which of severalcategories to which a given input belong; regression algorithms canoutput a numerical value given an input; and pattern recognitionalgorithms can be used to generate translated text or perform text tospeech and/or speech recognition.

An example type of machine learning algorithm is a neural network. Thereare many types of neural networks; a simple type of neural network is afeedforward network. A feedforward network may be implemented as anacyclic graph in which the nodes are arranged in layers. Typically, afeedforward network topology includes an input layer and an output layerthat are separated by at least one hidden layer. The hidden layertransforms input received by the input layer into a representation thatis useful for generating output in the output layer. The network nodesare fully connected via edges to the nodes in adjacent layers, but thereare no edges between nodes within each layer. Data received at the nodesof an input layer of a feedforward network are propagated (i.e., “fedforward”) to the nodes of the output layer via an activation functionthat calculates the states of the nodes of each successive layer in thenetwork based on coefficients (“weights”) respectively associated witheach of the edges connecting the layers. Depending on the specific modelbeing represented by the algorithm being executed, the output from theneural network algorithm can take various forms.

Before a machine learning algorithm can be used to model a particularproblem, the algorithm is trained using a training data set. Training aneural network involves selecting a network topology, using a set oftraining data representing a problem being modeled by the network, andadjusting the weights until the network model performs with a minimalerror for all instances of the training data set. For example, during asupervised learning training process for a neural network, the outputproduced by the network in response to the input representing aninstance in a training data set is compared to the “correct” labeledoutput for that instance, an error signal representing the differencebetween the output and the labeled output is calculated, and the weightsassociated with the connections are adjusted to minimize that error asthe error signal is backward propagated through the layers of thenetwork. The network is considered “trained” when the errors for each ofthe outputs generated from the instances of the training data set areminimized.

The accuracy of a machine learning algorithm can be affectedsignificantly by the quality of the data set used to train thealgorithm. The training process can be computationally intensive and mayutilize a significant amount of time on a conventional general-purposeprocessor. Accordingly, parallel processing hardware is used to trainmany types of machine learning algorithms. This is particularly usefulfor optimizing the training of neural networks, as the computationsperformed in adjusting the coefficients in neural networks lendthemselves naturally to parallel implementations. Specifically, manymachine learning algorithms and software applications have been adaptedto make use of the parallel processing hardware within general-purposegraphics processing devices.

FIG. 6 is a generalized diagram of a machine learning software stack600. A machine learning application 602 is any logic that can beconfigured to train a neural network using a training dataset or to usea trained deep neural network to implement machine intelligence. Themachine learning application 602 can include training and inferencefunctionality for a neural network and/or specialized software that canbe used to train a neural network before deployment. The machinelearning application 602 can implement any type of machine intelligenceincluding but not limited to image recognition, mapping andlocalization, autonomous navigation, speech synthesis, medical imaging,or language translation. Example machine learning applications 602include, but are not limited to, voice-based virtual assistants, imageor facial recognition algorithms, autonomous navigation, and thesoftware tools that are used to train the machine learning models usedby the machine learning applications 602.

Hardware acceleration for the machine learning application 602 can beenabled via a machine learning framework 604. The machine learningframework 604 can provide a library of machine learning primitives.Machine learning primitives are basic operations that are commonlyperformed by machine learning algorithms. Without the machine learningframework 604, developers of machine learning algorithms would beutilized to create and optimize the main computational logic associatedwith the machine learning algorithm, then re-optimize the computationallogic as new parallel processors are developed. Instead, the machinelearning application can be configured to perform the computations usingthe primitives provided by the machine learning framework 604. Exampleprimitives include tensor convolutions, activation functions, andpooling, which are computational operations that are performed whiletraining a convolutional neural network (CNN). The machine learningframework 604 can also provide primitives to implement basic linearalgebra subprograms performed by many machine-learning algorithms, suchas matrix and vector operations. Examples of a machine learningframework 604 include, but are not limited to, TensorFlow, TensorRT,PyTorch, MXNet, Caffee, and other high-level machine learningframeworks.

The machine learning framework 604 can process input data received fromthe machine learning application 602 and generate the appropriate inputto a compute framework 606. The compute framework 606 can abstract theunderlying instructions provided to the GPGPU driver 608 to enable themachine learning framework 604 to take advantage of hardwareacceleration via the GPGPU hardware 610 without requiring the machinelearning framework 604 to have intimate knowledge of the architecture ofthe GPGPU hardware 610. Additionally, the compute framework 606 canenable hardware acceleration for the machine learning framework 604across a variety of types and generations of the GPGPU hardware 610.Example compute frameworks 606 include the CUDA compute framework andassociated machine learning libraries, such as the CUDA Deep NeuralNetwork (cuDNN) library. The machine learning software stack 600 canalso include communication libraries or frameworks to facilitatemulti-GPU and multi-node compute.

GPGPU Machine Learning Acceleration

FIG. 7 illustrates a general-purpose graphics processing unit 700, whichmay be the parallel processor 200 of FIG. 2A or the parallelprocessor(s) 112 of FIG. 1 . The general-purpose processing unit (GPGPU)700 may be configured to provide support for hardware acceleration ofprimitives provided by a machine learning framework to accelerate theprocessing the type of computational workloads associated with trainingdeep neural networks. Additionally, the GPGPU 700 can be linked directlyto other instances of the GPGPU to create a multi-GPU cluster to improvetraining speed for particularly deep neural networks. Primitives arealso supported to accelerate inference operations for deployed neuralnetworks.

The GPGPU 700 includes a host interface 702 to enable a connection witha host processor. The host interface 702 may be a PCI Express interface.However, the host interface can also be a vendor specific communicationsinterface or communications fabric. The GPGPU 700 receives commands fromthe host processor and uses a global scheduler 704 to distributeexecution threads associated with those commands to a set of processingclusters 706A-706H. The processing clusters 706A-706H share a cachememory 708. The cache memory 708 can serve as a higher-level cache forcache memories within the processing clusters 706A-706H. The illustratedprocessing clusters 706A-706H may correspond with processing clusters214A-214N as in FIG. 2A.

The GPGPU 700 includes memory 714A-714B coupled with the processingclusters 706A-706H via a set of memory controllers 712A-712B. The memory714A-714B can include various types of memory devices including dynamicrandom-access memory (DRAM) or graphics random access memory, such assynchronous graphics random access memory (SGRAM), including graphicsdouble data rate (GDDR) memory. The memory 714A-714B may also include 3Dstacked memory, including but not limited to high bandwidth memory(HBM).

Each of the processing clusters 706A-706H may include a set of graphicsmultiprocessors, such as the graphics multiprocessor 234 of FIG. 2D,graphics multiprocessor 325 of FIG. 3A, graphics multiprocessor 350 ofFIG. 3B, or may include a multi-core group 365A-365N as in FIG. 3C. Thegraphics multiprocessors of the compute cluster include multiple typesof integer and floating-point logic units that can perform computationaloperations at a range of precisions including suited for machinelearning computations. For example, at least a subset of thefloating-point units in each of the processing clusters 706A-706H can beconfigured to perform 16-bit or 32-bit floating point operations, whilea different subset of the floating-point units can be configured toperform 64-bit floating point operations.

Multiple instances of the GPGPU 700 can be configured to operate as acompute cluster. The communication mechanism used by the compute clusterfor synchronization and data exchange varies across embodiments. Forexample, the multiple instances of the GPGPU 700 communicate over thehost interface 702. In one embodiment the GPGPU 700 includes an I/O hub709 that couples the GPGPU 700 with a GPU link 710 that enables a directconnection to other instances of the GPGPU. The GPU link 710 may becoupled to a dedicated GPU-to-GPU bridge that enables communication andsynchronization between multiple instances of the GPGPU 700. Optionally,the GPU link 710 couples with a high-speed interconnect to transmit andreceive data to other GPGPUs or parallel processors. The multipleinstances of the GPGPU 700 may be located in separate data processingsystems and communicate via a network device that is accessible via thehost interface 702. The GPU link 710 may be configured to enable aconnection to a host processor in addition to or as an alternative tothe host interface 702.

While the illustrated configuration of the GPGPU 700 can be configuredto train neural networks, an alternate configuration of the GPGPU 700can be configured for deployment within a high performance or low powerinferencing platform. In an inferencing configuration, the GPGPU 700includes fewer of the processing clusters 706A-706H relative to thetraining configuration. Additionally, memory technology associated withthe memory 714A-714B may differ between inferencing and trainingconfigurations. In one embodiment, the inferencing configuration of theGPGPU 700 can support inferencing specific instructions. For example, aninferencing configuration can provide support for one or more 8-bitinteger dot product instructions, which are commonly used duringinferencing operations for deployed neural networks.

FIG. 8 illustrates a multi-GPU computing system 800. The multi-GPUcomputing system 800 can include a processor 802 coupled to multipleGPGPUs 806A-806D via a host interface switch 804. The host interfaceswitch 804 may be a PCI express switch device that couples the processor802 to a PCI express bus over which the processor 802 can communicatewith the set of GPGPUs 806A-806D. Each of the multiple GPGPUs 806A-806Dcan be an instance of the GPGPU 700 of FIG. 7 . The GPGPUs 806A-806D caninterconnect via a set of high-speed point to point GPU to GPU links816. The high-speed GPU to GPU links can connect to each of the GPGPUs806A-806D via a dedicated GPU link, such as the GPU link 710 as in FIG.7 . The P2P GPU links 816 enable direct communication between each ofthe GPGPUs 806A-806D without requiring communication over the hostinterface bus to which the processor 802 is connected. With GPU-to-GPUtraffic directed to the P2P GPU links, the host interface bus remainsavailable for system memory access or to communicate with otherinstances of the multi-GPU computing system 800, for example, via one ormore network devices. While in FIG. 8 the GPGPUs 806A-806D connect tothe processor 802 via the host interface switch 804, the processor 802may alternatively include direct support for the P2P GPU links 816 andconnect directly to the GPGPUs 806A-806D. In one embodiment the P2P GPUlink 816 enable the multi-GPU computing system 800 to operate as asingle logical GPU.

Machine Learning Neural Network Implementations

The computing architecture described herein can be configured to performthe types of parallel processing that is particularly suited fortraining and deploying neural networks for machine learning. A neuralnetwork can be generalized as a network of functions having a graphrelationship. As is well-known in the art, there are a variety of typesof neural network implementations used in machine learning. One exampletype of neural network is the feedforward network, as previouslydescribed.

A second example type of neural network is the Convolutional NeuralNetwork (CNN). A CNN is a specialized feedforward neural network forprocessing data having a known, grid-like topology, such as image data.Accordingly, CNNs are commonly used for compute vision and imagerecognition applications, but they also may be used for other types ofpattern recognition such as speech and language processing. The nodes inthe CNN input layer are organized into a set of “filters” (featuredetectors inspired by the receptive fields found in the retina), and theoutput of each set of filters is propagated to nodes in successivelayers of the network. The computations for a CNN include applying theconvolution mathematical operation to each filter to produce the outputof that filter. Convolution is a specialized kind of mathematicaloperation performed by two functions to produce a third function that isa modified version of one of the two original functions. Inconvolutional network terminology, the first function to the convolutioncan be referred to as the input, while the second function can bereferred to as the convolution kernel. The output may be referred to asthe feature map. For example, the input to a convolution layer can be amultidimensional array of data that defines the various color componentsof an input image. The convolution kernel can be a multidimensionalarray of parameters, where the parameters are adapted by the trainingprocess for the neural network.

Recurrent neural networks (RNNs) are a family of feedforward neuralnetworks that include feedback connections between layers. RNNs enablemodeling of sequential data by sharing parameter data across differentparts of the neural network. The architecture for an RNN includescycles. The cycles represent the influence of a present value of avariable on its own value at a future time, as at least a portion of theoutput data from the RNN is used as feedback for processing subsequentinput in a sequence. This feature makes RNNs particularly useful forlanguage processing due to the variable nature in which language datacan be composed.

The figures described below present example feedforward, CNN, and RNNnetworks, as well as describe a general process for respectivelytraining and deploying each of those types of networks. It can beunderstood that these descriptions are example and non-limiting as toany specific embodiment described herein and the concepts illustratedcan be applied generally to deep neural networks and machine learningtechniques in general.

The example neural networks described above can be used to perform deeplearning. Deep learning is machine learning using deep neural networks.The deep neural networks used in deep learning are artificial neuralnetworks composed of multiple hidden layers, as opposed to shallowneural networks that include a single hidden layer. Deeper neuralnetworks are generally more computationally intensive to train. However,the additional hidden layers of the network enable multistep patternrecognition that results in reduced output error relative to shallowmachine learning techniques.

Deep neural networks used in deep learning typically include a front-endnetwork to perform feature recognition coupled to a back-end networkwhich represents a mathematical model that can perform operations (e.g.,object classification, speech recognition, etc.) based on the featurerepresentation provided to the model. Deep learning enables machinelearning to be performed without requiring hand crafted featureengineering to be performed for the model. Instead, deep neural networkscan learn features based on statistical structure or correlation withinthe input data. The learned features can be provided to a mathematicalmodel that can map detected features to an output. The mathematicalmodel used by the network is generally specialized for the specific taskto be performed, and different models can be used to perform differenttask.

Once the neural network is structured, a learning model can be appliedto the network to train the network to perform specific tasks. Thelearning model describes how to adjust the weights within the model toreduce the output error of the network. Backpropagation of errors is acommon method used to train neural networks. An input vector ispresented to the network for processing. The output of the network iscompared to the desired output using a loss function and an error valueis calculated for each of the neurons in the output layer. The errorvalues are then propagated backwards until each neuron has an associatederror value which roughly represents its contribution to the originaloutput. The network can then learn from those errors using an algorithm,such as the stochastic gradient descent algorithm, to update the weightsof the of the neural network.

FIG. 9A-9B illustrate an example convolutional neural network. FIG. 9Aillustrates various layers within a CNN. As shown in FIG. 9A, an exampleCNN used to model image processing can receive input 902 describing thered, green, and blue (RGB) components of an input image. The input 902can be processed by multiple convolutional layers (e.g., convolutionallayer 904, convolutional layer 906). The output from the multipleconvolutional layers may optionally be processed by a set of fullyconnected layers 908. Neurons in a fully connected layer have fullconnections to all activations in the previous layer, as previouslydescribed for a feedforward network. The output from the fully connectedlayers 908 can be used to generate an output result from the network.The activations within the fully connected layers 908 can be computedusing matrix multiplication instead of convolution. Not all CNNimplementations make use of fully connected layers 908. For example, insome implementations the convolutional layer 906 can generate output forthe CNN.

The convolutional layers are sparsely connected, which differs fromtraditional neural network configuration found in the fully connectedlayers 908. Traditional neural network layers are fully connected, suchthat each output unit interacts with each input unit. However, theconvolutional layers are sparsely connected because the output of theconvolution of a field is input (instead of the respective state valueof each of the nodes in the field) to the nodes of the subsequent layer,as illustrated. The kernels associated with the convolutional layersperform convolution operations, the output of which is sent to the nextlayer. The dimensionality reduction performed within the convolutionallayers is one aspect that enables the CNN to scale to process largeimages.

FIG. 9B illustrates example computation stages within a convolutionallayer of a CNN. Input to a convolutional layer 912 of a CNN can beprocessed in three stages of a convolutional layer 914. The three stagescan include a convolution stage 916, a detector stage 918, and a poolingstage 920. The convolutional layer 914 can then output data to asuccessive convolutional layer. The final convolutional layer of thenetwork can generate output feature map data or provide input to a fullyconnected layer, for example, to generate a classification value for theinput to the CNN.

In the convolution stage 916 performs several convolutions in parallelto produce a set of linear activations. The convolution stage 916 caninclude an affine transformation, which is any transformation that canbe specified as a linear transformation plus a translation. Affinetransformations include rotations, translations, scaling, andcombinations of these transformations. The convolution stage computesthe output of functions (e.g., neurons) that are connected to specificregions in the input, which can be determined as the local regionassociated with the neuron. The neurons compute a dot product betweenthe weights of the neurons and the region in the local input to whichthe neurons are connected. The output from the convolution stage 916defines a set of linear activations that are processed by successivestages of the convolutional layer 914.

The linear activations can be processed by a detector stage 918. In thedetector stage 918, each linear activation is processed by a non-linearactivation function. The non-linear activation function increases thenonlinear properties of the overall network without affecting thereceptive fields of the convolution layer. Several types of non-linearactivation functions may be used. One particular type is the rectifiedlinear unit (ReLU), which uses an activation function defined asƒ(x)=max (0, x), such that the activation is thresholded at zero.

The pooling stage 920 uses a pooling function that replaces the outputof the convolutional layer 906 with a summary statistic of the nearbyoutputs. The pooling function can be used to introduce translationinvariance into the neural network, such that small translations to theinput do not change the pooled outputs. Invariance to local translationcan be useful in scenarios where the presence of a feature in the inputdata is more important than the precise location of the feature. Varioustypes of pooling functions can be used during the pooling stage 920,including max pooling, average pooling, and 12-norm pooling.Additionally, some CNN implementations do not include a pooling stage.Instead, such implementations substitute and additional convolutionstage having an increased stride relative to previous convolutionstages.

The output from the convolutional layer 914 can then be processed by thenext layer 922. The next layer 922 can be an additional convolutionallayer or one of the fully connected layers 908. For example, the firstconvolutional layer 904 of FIG. 9A can output to the secondconvolutional layer 906, while the second convolutional layer can outputto a first layer of the fully connected layers 908.

FIG. 10 illustrates an example recurrent neural network 1000. In arecurrent neural network (RNN), the previous state of the networkinfluences the output of the current state of the network. RNNs can bebuilt in a variety of ways using a variety of functions. The use of RNNsgenerally revolves around using mathematical models to predict thefuture based on a prior sequence of inputs. For example, an RNN may beused to perform statistical language modeling to predict an upcomingword given a previous sequence of words. The illustrated RNN 1000 can bedescribed has having an input layer 1002 that receives an input vector,hidden layers 1004 to implement a recurrent function, a feedbackmechanism 1005 to enable a ‘memory’ of previous states, and an outputlayer 1006 to output a result. The RNN 1000 operates based ontime-steps. The state of the RNN at a given time step is influencedbased on the previous time step via the feedback mechanism 1005. For agiven time step, the state of the hidden layers 1004 is defined by theprevious state and the input at the current time step. An initial input(x₁) at a first time step can be processed by the hidden layer 1004. Asecond input (x₂) can be processed by the hidden layer 1004 using stateinformation that is determined during the processing of the initialinput (x₁). A given state can be computed as s_(t)=ƒ(Ux_(t)+Ws_(t−1)),where U and W are parameter matrices. The function ƒis generally anonlinearity, such as the hyperbolic tangent function (Tanh) or avariant of the rectifier function ƒ(x)=max(0, x). However, the specificmathematical function used in the hidden layers 1004 can vary dependingon the specific implementation details of the RNN 1000.

In addition to the basic CNN and RNN networks described, accelerationfor variations on those networks may be enabled. One example RNN variantis the long short term memory (LSTM) RNN. LSTM RNNs are capable oflearning long-term dependencies that may be utilized for processinglonger sequences of language. A variant on the CNN is a convolutionaldeep belief network, which has a structure similar to a CNN and istrained in a manner similar to a deep belief network. A deep beliefnetwork (DBN) is a generative neural network that is composed ofmultiple layers of stochastic (random) variables. DBNs can be trainedlayer-by-layer using greedy unsupervised learning. The learned weightsof the DBN can then be used to provide pre-train neural networks bydetermining an initial set of weights for the neural network. In furtherembodiments, acceleration for reinforcement learning is enabled. Inreinforcement learning, an artificial agent learn by interacting withits environment. The agent is configured to optimize one or moreobjectives to maximize cumulative rewards.

FIG. 11 illustrates training and deployment of a deep neural network.Once a given network has been structured for a task the neural networkis trained using a training dataset 1102. Various training frameworks1104 have been developed to enable hardware acceleration of the trainingprocess. For example, the machine learning framework 604 of FIG. 6 maybe configured as a training framework 1104. The training framework 1104can hook into an untrained neural network 1106 and enable the untrainedneural net to be trained using the parallel processing resourcesdescribed herein to generate a trained neural network 1108.

To start the training process the initial weights may be chosen randomlyor by pre-training using a deep belief network. The training cycle thenbe performed in either a supervised or unsupervised manner.

Supervised learning is a learning method in which training is performedas a mediated operation, such as when the training dataset 1102 includesinput paired with the desired output for the input, or where thetraining dataset includes input having known output and the output ofthe neural network is manually graded. The network processes the inputsand compares the resulting outputs against a set of expected or desiredoutputs. Errors are then propagated back through the system. Thetraining framework 1104 can adjust to adjust the weights that controlthe untrained neural network 1106. The training framework 1104 canprovide tools to monitor how well the untrained neural network 1106 isconverging towards a model suitable to generating correct answers basedon known input data. The training process occurs repeatedly as theweights of the network are adjusted to refine the output generated bythe neural network. The training process can continue until the neuralnetwork reaches a statistically desired accuracy associated with atrained neural net 1108. The trained neural network 1108 can then bedeployed to implement any number of machine learning operations togenerate an inference result 1114 based on input of new data 1112.

Unsupervised learning is a learning method in which the network attemptsto train itself using unlabeled data. Thus, for unsupervised learningthe training dataset 1102 can include input data without any associatedoutput data. The untrained neural network 1106 can learn groupingswithin the unlabeled input and can determine how individual inputs arerelated to the overall dataset. Unsupervised training can be used togenerate a self-organizing map, which is a type of trained neuralnetwork 1108 capable of performing operations useful in reducing thedimensionality of data. Unsupervised training can also be used toperform anomaly detection, which allows the identification of datapoints in an input dataset that deviate from the normal patterns of thedata.

Variations on supervised and unsupervised training may also be employed.Semi-supervised learning is a technique in which in the training dataset1102 includes a mix of labeled and unlabeled data of the samedistribution. Incremental learning is a variant of supervised learningin which input data is continuously used to further train the model.Incremental learning enables the trained neural network 1108 to adapt tothe new data 1112 without forgetting the knowledge instilled within thenetwork during initial training.

Whether supervised or unsupervised, the training process forparticularly deep neural networks may be too computationally intensivefor a single compute node. Instead of using a single compute node, adistributed network of computational nodes can be used to accelerate thetraining process.

FIG. 12A is a block diagram illustrating distributed learning.Distributed learning is a training model that uses multiple distributedcomputing nodes to perform supervised or unsupervised training of aneural network. The distributed computational nodes can each include oneor more host processors and one or more of the general-purposeprocessing nodes, such as the highly parallel general-purpose graphicsprocessing unit 700 as in FIG. 7 . As illustrated, distributed learningcan be performed with model parallelism 1202, data parallelism 1204, ora combination of model and data parallelism 1206.

In model parallelism 1202, different computational nodes in adistributed system can perform training computations for different partsof a single network. For example, each layer of a neural network can betrained by a different processing node of the distributed system. Thebenefits of model parallelism include the ability to scale toparticularly large models. Splitting the computations associated withdifferent layers of the neural network enables the training of verylarge neural networks in which the weights of all layers would not fitinto the memory of a single computational node. In some instances, modelparallelism can be particularly useful in performing unsupervisedtraining of large neural networks.

In data parallelism 1204, the different nodes of the distributed networkhave a complete instance of the model and each node receives a differentportion of the data. The results from the different nodes are thencombined. While different approaches to data parallelism are possible,data parallel training approaches all utilize a technique of combiningresults and synchronizing the model parameters between each node.Example approaches to combining data include parameter averaging andupdate based data parallelism. Parameter averaging trains each node on asubset of the training data and sets the global parameters (e.g.,weights, biases) to the average of the parameters from each node.Parameter averaging uses a central parameter server that maintains theparameter data. Update based data parallelism is similar to parameteraveraging except that instead of transferring parameters from the nodesto the parameter server, the updates to the model are transferred.Additionally, update based data parallelism can be performed in adecentralized manner, where the updates are compressed and transferredbetween nodes.

Combined model and data parallelism 1206 can be implemented, forexample, in a distributed system in which each computational nodeincludes multiple GPUs. Each node can have a complete instance of themodel with separate GPUs within each node are used to train differentportions of the model.

Distributed training has increased overhead relative to training on asingle machine. However, the parallel processors and GPGPUs describedherein can each implement various techniques to reduce the overhead ofdistributed training, including techniques to enable high bandwidthGPU-to-GPU data transfer and accelerated remote data synchronization.

FIG. 12B is a block diagram illustrating a programmable networkinterface 1210 and data processing unit. The programmable networkinterface 1210 is a programmable network engine that can be used toaccelerate network-based compute tasks within a distributed environment.The programmable network interface 1210 can couple with a host systemvia host interface 1270. The programmable network interface 1210 can beused to accelerate network or storage operations for CPUs or GPUs of thehost system. The host system can be, for example, a node of adistributed learning system used to perform distributed training, forexample, as shown in FIG. 12A. The host system can also be a data centernode within a data center.

In one embodiment, access to remote storage containing model data can beaccelerated by the programmable network interface 1210. For example, theprogrammable network interface 1210 can be configured to present remotestorage devices as local storage devices to the host system. Theprogrammable network interface 1210 can also accelerate remote directmemory access (RDMA) operations performed between GPUs of the hostsystem with GPUs of remote systems. In one embodiment, the programmablenetwork interface 1210 can enable storage functionality such as, but notlimited to NVME-oF. The programmable network interface 1210 can alsoaccelerate encryption, data integrity, compression, and other operationsfor remote storage on behalf of the host system, allowing remote storageto approach the latencies of storage devices that are directly attachedto the host system.

The programmable network interface 1210 can also perform resourceallocation and management on behalf of the host system. Storage securityoperations can be offloaded to the programmable network interface 1210and performed in concert with the allocation and management of remotestorage resources. Network-based operations to manage access to theremote storage that would otherwise by performed by a processor of thehost system can instead be performed by the programmable networkinterface 1210.

In one embodiment, network and/or data security operations can beoffloaded from the host system to the programmable network interface1210. Data center security policies for a data center node can behandled by the programmable network interface 1210 instead of theprocessors of the host system. For example, the programmable networkinterface 1210 can detect and mitigate against an attemptednetwork-based attack (e.g., DDoS) on the host system, preventing theattack from compromising the availability of the host system.

The programmable network interface 1210 can include a system on a chip(SoC 1220) that executes an operating system via multiple processorcores 1222. The processor cores 1222 can include general-purposeprocessor (e.g., CPU) cores. In one embodiment the processor cores 1222can also include one or more GPU cores. The SoC 1220 can executeinstructions stored in a memory device 1240. A storage device 1250 canstore local operating system data. The storage device 1250 and memorydevice 1240 can also be used to cache remote data for the host system.Network ports 1260A-1260B enable a connection to a network or fabric andfacilitate network access for the SoC 1220 and, via the host interface1270, for the host system. The programmable network interface 1210 canalso include an I/O interface 1275, such as a USB interface. The I/Ointerface 1275 can be used to couple external devices to theprogrammable network interface 1210 or as a debug interface. Theprogrammable network interface 1210 also includes a management interface1230 that enables software on the host device to manage and configurethe programmable network interface 1210 and/or SoC 1220. In oneembodiment the programmable network interface 1210 may also include oneor more accelerators or GPUs 1245 to accept offload of parallel computetasks from the SoC 1220, host system, or remote systems coupled via thenetwork ports 1260A-1260B.

Example Machine Learning Applications

Machine learning can be applied to solve a variety of technologicalproblems, including but not limited to computer vision, autonomousdriving and navigation, speech recognition, and language processing.Computer vision has traditionally been an active research areas formachine learning applications. Applications of computer vision rangefrom reproducing human visual abilities, such as recognizing faces, tocreating new categories of visual abilities. For example, computervision applications can be configured to recognize sound waves from thevibrations induced in objects visible in a video. Parallel processoraccelerated machine learning enables computer vision applications to betrained using significantly larger training dataset than previouslyfeasible and enables inferencing systems to be deployed using low powerparallel processors.

Parallel processor accelerated machine learning has autonomous drivingapplications including lane and road sign recognition, obstacleavoidance, navigation, and driving control. Accelerated machine learningtechniques can be used to train driving models based on datasets thatdefine the appropriate responses to specific training input. Theparallel processors described herein can enable rapid training of theincreasingly complex neural networks used for autonomous drivingsolutions and enables the deployment of low power inferencing processorsin a mobile platform suitable for integration into autonomous vehicles.

Parallel processor accelerated deep neural networks have enabled machinelearning approaches to automatic speech recognition (ASR). ASR includesthe creation of a function that computes a probable linguistic sequencegiven an input acoustic sequence. Accelerated machine learning usingdeep neural networks have enabled the replacement of the hidden Markovmodels (HMMs) and Gaussian mixture models (GMMs) previously used forASR.

Parallel processor accelerated machine learning can also be used toaccelerate natural language processing. Automatic learning procedurescan make use of statistical inference algorithms to produce models thatare robust to erroneous or unfamiliar input. Example natural languageprocessor applications include automatic machine translation betweenhuman languages.

The parallel processing platforms used for machine learning can bedivided into training platforms and deployment platforms. Trainingplatforms are generally highly parallel and include optimizations toaccelerate multi-GPU single node training and multi-node, multi-GPUtraining. Example parallel processors suited for training include thegeneral-purpose graphics processing unit 700 of FIG. 7 and the multi-GPUcomputing system 800 of FIG. 8 . On the contrary, deployed machinelearning platforms generally include lower power parallel processorssuitable for use in products such as cameras, autonomous robots, andautonomous vehicles.

Additionally, machine learning techniques can be applied to accelerateor enhance graphics processing activities. For example, a machinelearning model can be trained to recognize output generated by a GPUaccelerated application and generate an upscaled version of that output.Such techniques can be applied to accelerate the generation of highresolution images for a gaming application. Various other graphicspipeline activities can benefit from the use of machine learning. Forexample, machine learning models can be trained to perform tessellationoperations on geometry data to increase the complexity of geometricmodels, allowing fine-detailed geometry to be automatically generatedfrom geometry of relatively lower detail.

FIG. 13 illustrates an example inferencing system on a chip (SOC) 1300suitable for performing inferencing using a trained model. The SOC 1300can integrate processing components including a media processor 1302, avision processor 1304, a GPGPU 1306 and a multi-core processor 1308. TheGPGPU 1306 may be a GPGPU as described herein, such as the GPGPU 700,and the multi-core processor 1308 may be a multi-core processordescribed herein, such as the multi-core processors 405-406. The SOC1300 can additionally include on-chip memory 1305 that can enable ashared on-chip data pool that is accessible by each of the processingcomponents. The processing components can be optimized for low poweroperation to enable deployment to a variety of machine learningplatforms, including autonomous vehicles and autonomous robots. Forexample, one implementation of the SOC 1300 can be used as a portion ofthe main control system for an autonomous vehicle. Where the SOC 1300 isconfigured for use in autonomous vehicles the SOC is designed andconfigured for compliance with the relevant functional safety standardsof the deployment jurisdiction.

During operation, the media processor 1302 and vision processor 1304 canwork in concert to accelerate computer vision operations. The mediaprocessor 1302 can enable low latency decode of multiple high-resolution(e.g., 4K, 8K) video streams. The decoded video streams can be writtento a buffer in the on-chip memory 1305. The vision processor 1304 canthen parse the decoded video and perform preliminary processingoperations on the frames of the decoded video in preparation ofprocessing the frames using a trained image recognition model. Forexample, the vision processor 1304 can accelerate convolution operationsfor a CNN that is used to perform image recognition on thehigh-resolution video data, while back end model computations areperformed by the GPGPU 1306.

The multi-core processor 1308 can include control logic to assist withsequencing and synchronization of data transfers and shared memoryoperations performed by the media processor 1302 and the visionprocessor 1304. The multi-core processor 1308 can also function as anapplication processor to execute software applications that can make useof the inferencing compute capability of the GPGPU 1306. For example, atleast a portion of the navigation and driving logic can be implementedin software executing on the multi-core processor 1308. Such softwarecan directly issue computational workloads to the GPGPU 1306 or thecomputational workloads can be issued to the multi-core processor 1308,which can offload at least a portion of those operations to the GPGPU1306.

The GPGPU 1306 can include compute clusters such as a low powerconfiguration of the processing clusters 706A-706H withingeneral-purpose graphics processing unit 700. The compute clusterswithin the GPGPU 1306 can support instruction that are specificallyoptimized to perform inferencing computations on a trained neuralnetwork. For example, the GPGPU 1306 can support instructions to performlow precision computations such as 8-bit and 4-bit integer vectoroperations.

Additional System Overview

FIG. 14 is a block diagram of a processing system 1400. The elements ofFIG. 14 having the same or similar names as the elements of any otherfigure herein describe the same elements as in the other figures, canoperate or function in a manner similar to that, can comprise the samecomponents, and can be linked to other entities, as those describedelsewhere herein, but are not limited to such. system 1400 may be usedin a single processor desktop system, a multiprocessor workstationsystem, or a server system having a large number of processors 1402 orprocessor cores 1407. The system 1400 may be a processing platformincorporated within a system-on-a-chip (SoC) integrated circuit for usein mobile, handheld, or embedded devices such as withinInternet-of-things (IoT) devices with wired or wireless connectivity toa local or wide area network.

The system 1400 may be a processing system having components thatcorrespond with those of FIG. 1 . For example, in differentconfigurations, processor(s) 1402 or processor core(s) 1407 maycorrespond with processor(s) 102 of FIG. 1 . Graphics processor(s) 1408may correspond with parallel processor(s) 112 of FIG. 1 . Externalgraphics processor 1418 may be one of the add-in device(s) 120 of FIG. 1.

The system 1400 can include, couple with, or be integrated within: aserver-based gaming platform; a game console, including a game and mediaconsole; a mobile gaming console, a handheld game console, or an onlinegame console. The system 1400 may be part of a mobile phone, smartphone, tablet computing device or mobile Internet-connected device suchas a laptop with low internal storage capacity. Processing system 1400can also include, couple with, or be integrated within: a wearabledevice, such as a smart watch wearable device; smart eyewear or clothingenhanced with augmented reality (AR) or virtual reality (VR) features toprovide visual, audio or tactile outputs to supplement real worldvisual, audio or tactile experiences or otherwise provide text, audio,graphics, video, holographic images or video, or tactile feedback; otheraugmented reality (AR) device; or other virtual reality (VR) device. Theprocessing system 1400 may include or be part of a television or set topbox device. The system 1400 can include, couple with, or be integratedwithin a self-driving vehicle such as a bus, tractor trailer, car, motoror electric power cycle, plane or glider (or any combination thereof).The self-driving vehicle may use system 1400 to process the environmentsensed around the vehicle.

The one or more processors 1402 may include one or more processor cores1407 to process instructions which, when executed, perform operationsfor system or user software. The least one of the one or more processorcores 1407 may be configured to process a specific instruction set 1409.The instruction set 1409 may facilitate Complex Instruction SetComputing (CISC), Reduced Instruction Set Computing (RISC), or computingvia a Very Long Instruction Word (VLIW). One or more processor cores1407 may process a different instruction set 1409, which may includeinstructions to facilitate the emulation of other instruction sets.Processor core 1407 may also include other processing devices, such as aDigital Signal Processor (DSP).

The processor 1402 may include cache memory 1404. Depending on thearchitecture, the processor 1402 can have a single internal cache ormultiple levels of internal cache. In some embodiments, the cache memoryis shared among various components of the processor 1402. In someembodiments, the processor 1402 also uses an external cache (e.g., aLevel-3 (L3) cache or Last Level Cache (LLC)) (not shown), which may beshared among processor cores 1407 using known cache coherencytechniques. A register file 1406 can be additionally included inprocessor 1402 and may include different types of registers for storingdifferent types of data (e.g., integer registers, floating pointregisters, status registers, and an instruction pointer register). Someregisters may be general-purpose registers, while other registers may bespecific to the design of the processor 1402.

The one or more processor(s) 1402 may be coupled with one or moreinterface bus(es) 1410 to transmit communication signals such asaddress, data, or control signals between processor 1402 and othercomponents in the system 1400. The interface bus 1410, in one of theseembodiments, can be a processor bus, such as a version of the DirectMedia Interface (DMI) bus. However, processor busses are not limited tothe DMI bus, and may include one or more Peripheral ComponentInterconnect buses (e.g., PCI, PCI express), memory busses, or othertypes of interface busses. For example, the processor(s) 1402 mayinclude an integrated memory controller 1416 and a platform controllerhub 1430. The memory controller 1416 facilitates communication between amemory device and other components of the system 1400, while theplatform controller hub (PCH) 1430 provides connections to I/O devicesvia a local I/O bus.

The memory device 1420 can be a dynamic random-access memory (DRAM)device, a static random-access memory (SRAM) device, flash memorydevice, phase-change memory device, or some other memory device havingsuitable performance to serve as process memory. The memory device 1420can, for example, operate as system memory for the system 1400, to storedata 1422 and instructions 1421 for use when the one or more processors1402 executes an application or process. Memory controller 1416 alsocouples with an optional external graphics processor 1418, which maycommunicate with the one or more graphics processors 1408 in processors1402 to perform graphics and media operations. In some embodiments,graphics, media, and or compute operations may be assisted by anaccelerator 1412 which is a coprocessor that can be configured toperform a specialized set of graphics, media, or compute operations. Forexample, the accelerator 1412 may be a matrix multiplication acceleratorused to optimize machine learning or compute operations. The accelerator1412 can be a ray-tracing accelerator that can be used to performray-tracing operations in concert with the graphics processor 1408. Inone embodiment, an external accelerator 1419 may be used in place of orin concert with the accelerator 1412.

A display device 1411 may be provided that can connect to theprocessor(s) 1402. The display device 1411 can be one or more of aninternal display device, as in a mobile electronic device or a laptopdevice or an external display device attached via a display interface(e.g., DisplayPort, etc.). The display device 1411 can be a head mounteddisplay (HMD) such as a stereoscopic display device for use in virtualreality (VR) applications or augmented reality (AR) applications.

The platform controller hub 1430 may enable peripherals to connect tomemory device 1420 and processor 1402 via a high-speed I/O bus. The I/Operipherals include, but are not limited to, an audio controller 1446, anetwork controller 1434, a firmware interface 1428, a wirelesstransceiver 1426, touch sensors 1425, a data storage device 1424 (e.g.,non-volatile memory, volatile memory, hard disk drive, flash memory,NAND, 3D NAND, 3D XPoint/Optane, etc.). The data storage device 1424 canconnect via a storage interface (e.g., SATA) or via a peripheral bus,such as a Peripheral Component Interconnect bus (e.g., PCI, PCIexpress). The touch sensors 1425 can include touch screen sensors,pressure sensors, or fingerprint sensors. The wireless transceiver 1426can be a Wi-Fi transceiver, a Bluetooth transceiver, or a mobile networktransceiver such as a 3G, 4G, 5G, or Long-Term Evolution (LTE)transceiver. The firmware interface 1428 enables communication withsystem firmware, and can be, for example, a unified extensible firmwareinterface (UEFI). The network controller 1434 can enable a networkconnection to a wired network. In some embodiments, a high-performancenetwork controller (not shown) couples with the interface bus 1410. Theaudio controller 1446 may be a multi-channel high definition audiocontroller. In some of these embodiments the system 1400 includes anoptional legacy I/O controller 1440 for coupling legacy (e.g., PersonalSystem 2 (PS/2)) devices to the system. The platform controller hub 1430can also connect to one or more Universal Serial Bus (USB) controllers1442 connect input devices, such as keyboard and mouse 1443combinations, a camera 1444, or other USB input devices.

It can be appreciated that the system 1400 shown is example and notlimiting, as other types of data processing systems that are differentlyconfigured may also be used. For example, an instance of the memorycontroller 1416 and platform controller hub 1430 may be integrated intoa discrete external graphics processor, such as the external graphicsprocessor 1418. The platform controller hub 1430 and/or memorycontroller 1416 may be external to the one or more processor(s) 1402.For example, the system 1400 can include an external memory controller1416 and platform controller hub 1430, which may be configured as amemory controller hub and peripheral controller hub within a systemchipset that is in communication with the processor(s) 1402.

For example, circuit boards (“sleds”) can be used on which componentssuch as CPUs, memory, and other components are placed are designed forincreased thermal performance. Processing components such as theprocessors may be located on a top side of a sled while near memory,such as DIMMs, are located on a bottom side of the sled. As a result ofthe enhanced airflow provided by this design, the components may operateat higher frequencies and power levels than in typical systems, therebyincreasing performance. Furthermore, the sleds are configured to blindlymate with power and data communication cables in a rack, therebyenhancing their ability to be quickly removed, upgraded, reinstalled,and/or replaced. Similarly, individual components located on the sleds,such as processors, accelerators, memory, and data storage drives, areconfigured to be easily upgraded due to their increased spacing fromeach other. In the illustrative embodiment, the components additionallyinclude hardware attestation features to prove their authenticity.

A data center can utilize a single network architecture (“fabric”) thatsupports multiple other network architectures including Ethernet andOmni-Path. The sleds can be coupled to switches via optical fibers,which provide higher bandwidth and lower latency than typical twistedpair cabling (e.g., Category 5, Category 5e, Category 6, etc.). Due tothe high bandwidth, low latency interconnections and networkarchitecture, the data center may, in use, pool resources, such asmemory, accelerators (e.g., GPUs, graphics accelerators, FPGAs, ASICs,neural network and/or artificial intelligence accelerators, etc.), anddata storage drives that are physically disaggregated, and provide themto compute resources (e.g., processors), enabling the compute resourcesto access the pooled resources as if they were local.

A power supply or source can provide voltage and/or current to system1400 or any component or system described herein. In one example, thepower supply includes an AC to DC (alternating current to directcurrent) adapter to plug into a wall outlet. Such AC power can berenewable energy (e.g., solar power) power source. In one example, thepower source includes a DC power source, such as an external AC to DCconverter. A power source or power supply may also include wirelesscharging hardware to charge via proximity to a charging field. The powersource can include an internal battery, alternating current supply,motion-based power supply, solar power supply, or fuel cell source.

FIG. 15A-15C illustrate computing systems and graphics processors. Theelements of FIG. 15A-15C having the same or similar names as theelements of any other figure herein describe the same elements as in theother figures, can operate or function in a manner similar to that, cancomprise the same components, and can be linked to other entities, asthose described elsewhere herein, but are not limited to such.

FIG. 15A is a block diagram of a processor 1500, which may be a variantof one of the processors 1402 and may be used in place of one of those.Therefore, the discussion of any features in combination with theprocessor 1500 herein also discloses a corresponding combination withthe processor(s) 1402, but is not limited to such. The processor 1500may have one or more processor cores 1502A-1502N, an integrated memorycontroller 1514, and an integrated graphics processor 1508. Where anintegrated graphics processor 1508 is excluded, the system that includesthe processor can include a graphics processor device within a systemchipset or coupled via a system bus. Processor 1500 can includeadditional cores up to and including additional core 1502N representedby the dashed lined boxes. Each of processor cores 1502A-1502N includesone or more internal cache units 1504A-1504N. In some embodiments eachprocessor core 1502A-1502N also has access to one or more shared cacheunits 1506. The internal cache units 1504A-1504N and shared cache units1506 represent a cache memory hierarchy within the processor 1500. Thecache memory hierarchy may include at least one level of instruction anddata cache within each processor core and one or more levels of sharedmid-level cache, such as a Level 2 (L2), Level 3 (L 3), Level 4 (L4), orother levels of cache, where the highest level of cache before externalmemory is classified as the LLC. In some embodiments, cache coherencylogic maintains coherency between the various cache units 1506 and1504A-1504N.

The processor 1500 may also include a set of one or more bus controllerunits 1516 and a system agent core 1510. The one or more bus controllerunits 1516 manage a set of peripheral buses, such as one or more PCI orPCI express busses. System agent core 1510 provides managementfunctionality for the various processor components. The system agentcore 1510 may include one or more integrated memory controllers 1514 tomanage access to various external memory devices (not shown).

For example, one or more of the processor cores 1502A-1502N may includesupport for simultaneous multi-threading. The system agent core 1510includes components for coordinating and operating cores 1502A-1502Nduring multi-threaded processing. System agent core 1510 mayadditionally include a power control unit (PCU), which includes logicand components to regulate the power state of processor cores1502A-1502N and graphics processor 1508.

The processor 1500 may additionally include graphics processor 1508 toexecute graphics processing operations. In some of these embodiments,the graphics processor 1508 couples with the set of shared cache units1506, and the system agent core 1510, including the one or moreintegrated memory controllers 1514. The system agent core 1510 may alsoinclude a display controller 1511 to drive graphics processor output toone or more coupled displays. The display controller 1511 may also be aseparate module coupled with the graphics processor via at least oneinterconnect, or may be integrated within the graphics processor 1508.

A ring-based interconnect unit 1512 may be used to couple the internalcomponents of the processor 1500. However, an alternative interconnectunit may be used, such as a point-to-point interconnect, a switchedinterconnect, or other techniques, including techniques well known inthe art. In some of these embodiments with a ring-based interconnect1512, the graphics processor 1508 couples with the ring-basedinterconnect 1512 via an I/O link 1513.

The example I/O link 1513 represents at least one of multiple varietiesof I/O interconnects, including an on package I/O interconnect whichfacilitates communication between various processor components and ahigh-performance embedded memory module 1518, such as an eDRAM module.Optionally, each of the processor cores 1502A-1502N and graphicsprocessor 1508 can use embedded memory modules 1518 as a shared LastLevel Cache.

The processor cores 1502A-1502N may, for example, be homogenous coresexecuting the same instruction set architecture. Alternatively, theprocessor cores 1502A-1502N are heterogeneous in terms of instructionset architecture (ISA), where one or more of processor cores 1502A-1502Nexecute a first instruction set, while at least one of the other coresexecutes a subset of the first instruction set or a differentinstruction set. The processor cores 1502A-1502N may be heterogeneous interms of microarchitecture, where one or more cores having a relativelyhigher power consumption couple with one or more power cores having alower power consumption. As another example, the processor cores1502A-1502N are heterogeneous in terms of computational capability.Additionally, processor 1500 can be implemented on one or more chips oras an SoC integrated circuit having the illustrated components, inaddition to other components.

FIG. 15B is a block diagram of hardware logic of a graphics processorcore 1519, according to some embodiments described herein. The graphicsprocessor core 1519, sometimes referred to as a core slice, can be oneor multiple graphics cores within a modular graphics processor. Thegraphics processor core 1519 is example of one graphics core slice, anda graphics processor as described herein may include multiple graphicscore slices based on target power and performance envelopes. Eachgraphics processor core 1519 can include a fixed function block 1530coupled with multiple sub-cores 1521A-1521F, also referred to assub-slices, that include modular blocks of general-purpose and fixedfunction logic. In one configuration, a sub-core (sub-slice) of themultiple sub-cores 1521A-1521F is an architectural equivalent to agraphics multiprocessor 234 of FIG. 2D, graphics multiprocessor 325 ofFIG. 3A, and/or a multi-core group of the multi-core groups 365A-365N ofFIG. 3C.

The fixed function block 1530 may include a geometry/fixed functionpipeline 1531 that can be shared by all sub-cores in the graphicsprocessor core 1519, for example, in lower performance and/or lowerpower graphics processor implementations. The geometry/fixed functionpipeline 1531 may include a 3D fixed function pipeline (e.g., 3Dpipeline 1612 as in FIG. 16A described below) a video front-end unit, athread spawner and thread dispatcher, and a unified return buffermanager, which manages unified return buffers (e.g., unified returnbuffer 1718 in FIG. 17 , as described below).

The fixed function block 1530 may also include a graphics SoC interface1532, a graphics microcontroller 1533, and a media pipeline 1534. Thegraphics SoC interface 1532 provides an interface between the graphicsprocessor core 1519 and other processor cores within a system on a chipintegrated circuit. The graphics microcontroller 1533 is a programmablesub-processor that is configurable to manage various functions of thegraphics processor core 1519, including thread dispatch, scheduling, andpre-emption. The media pipeline 1534 (e.g., media pipeline 1616 of FIG.16A and FIG. 17 ) includes logic to facilitate the decoding, encoding,pre-processing, and/or post-processing of multimedia data, includingimage and video data. The media pipeline 1534 implement media operationsvia requests to compute or sampling logic within the sub-cores1521-1521F.

The SoC interface 1532 may enable the graphics processor core 1519 tocommunicate with general-purpose application processor cores (e.g.,CPUs) and/or other components within an SoC, including memory hierarchyelements such as a shared last level cache memory, the system RAM,and/or embedded on-chip or on-package DRAM. The SoC interface 1532 canalso enable communication with fixed function devices within the SoC,such as camera imaging pipelines, and enables the use of and/orimplements global memory atomics that may be shared between the graphicsprocessor core 1519 and CPUs within the SoC. The SoC interface 1532 canalso implement power management controls for the graphics processor core1519 and enable an interface between a clock domain of the graphicsprocessor core 1519 and other clock domains within the SoC. Optionally,the SoC interface 1532 enables receipt of command buffers from a commandstreamer and global thread dispatcher that are configured to providecommands and instructions to each of one or more graphics cores within agraphics processor. The commands and instructions can be dispatched tothe media pipeline 1534, when media operations are to be performed, or ageometry and fixed function pipeline (e.g., geometry and fixed functionpipeline 1531, geometry and fixed function pipeline 1537) when graphicsprocessing operations are to be performed.

The graphics microcontroller 1533 can be configured to perform variousscheduling and management tasks for the graphics processor core 1519. Inone configuration the graphics microcontroller 1533 can, for example,perform graphics and/or compute workload scheduling on the variousgraphics parallel engines within execution unit (EU) arrays 1522A-1522F,1524A-1524F within the sub-cores 1521A-1521F. In this workloadscheduling, host software executing on a CPU core of an SoC includingthe graphics processor core 1519 can submit workloads to one of multiplegraphics processor doorbells, which invokes a scheduling operation onthe appropriate graphics engine. Scheduling operations includedetermining which workload to run next, submitting a workload to acommand streamer, pre-empting existing workloads running on an engine,monitoring progress of a workload, and notifying host software when aworkload is complete. Optionally, the graphics microcontroller 1533 canalso facilitate low-power or idle states for the graphics processor core1519, providing the graphics processor core 1519 with the ability tosave and restore registers within the graphics processor core 1519across low-power state transitions independently from the operatingsystem and/or graphics driver software on the system.

The graphics processor core 1519 may have more than or fewer than theillustrated sub-cores 1521A-1521F, up to N modular sub-cores. For eachset of N sub-cores, the graphics processor core 1519 can also includeshared function logic 1535, shared and/or cache memory 1536, ageometry/fixed function pipeline 1537, as well as additional fixedfunction logic 1538 to accelerate various graphics and computeprocessing operations. The shared function logic 1535 can include logicunits associated with the shared function logic 1720 of FIG. 17 (e.g.,sampler, math, and/or inter-thread communication logic) that can beshared by each N sub-cores within the graphics processor core 1519. Theshared and/or cache memory 1536 can be a last-level cache for the set ofN sub-cores 1521A-1521F within the graphics processor core 1519, and canalso serve as shared memory that is accessible by multiple sub-cores.The geometry/fixed function pipeline 1537 can be included instead of thegeometry/fixed function pipeline 1531 within the fixed function block1530 and can include the same or similar logic units.

The graphics processor core 1519 may include additional fixed functionlogic 1538 that can include various fixed function acceleration logicfor use by the graphics processor core 1519. Optionally, the additionalfixed function logic 1538 includes an additional geometry pipeline foruse in position-only shading. In position-only shading, two geometrypipelines exist, the full geometry pipeline within the geometry/fixedfunction pipeline 1538, 1531, and a cull pipeline, which is anadditional geometry pipeline which may be included within the additionalfixed function logic 1538. For example, the cull pipeline may be atrimmed down version of the full geometry pipeline. The full pipelineand the cull pipeline can execute different instances of the sameapplication, each instance having a separate context. Position-onlyshading can hide long cull runs of discarded triangles, enabling shadingto be completed earlier in some instances. For example, the cullpipeline logic within the additional fixed function logic 1538 canexecute position shaders in parallel with the main application andgenerally generates results faster than the full pipeline, as the cullpipeline fetches and shades the position attribute of the vertices,without performing rasterization and rendering of the pixels to theframe buffer. The cull pipeline can use the generated results to computevisibility information for all the triangles without regard to whetherthose triangles are culled. The full pipeline (which in this instancemay be referred to as a replay pipeline) can consume the visibilityinformation to skip the culled triangles to shade the visible trianglesthat are finally passed to the rasterization phase.

Optionally, the additional fixed function logic 1538 can also includemachine-learning acceleration logic, such as fixed function matrixmultiplication logic, for implementations including optimizations formachine learning training or inferencing.

Within each graphics sub-core 1521A-1521F a set of execution resourcesis included that may be used to perform graphics, media, and computeoperations in response to requests by graphics pipeline, media pipeline,or shader programs. The graphics sub-cores 1521A-1521F include multipleEU arrays 1522A-1522F, 1524A-1524F, thread dispatch and inter-threadcommunication (TD/IC) logic 1523A-1523F, a 3D (e.g., texture) sampler1525A-1525F, a media sampler 1526A-1526F, a shader processor1527A-1527F, and shared local memory (SLM) 1528A-1528F. The EU arrays1522A-1522F, 1524A-1524F each include multiple execution units, whichare general-purpose graphics processing units capable of performingfloating-point and integer/fixed-point logic operations in service of agraphics, media, or compute operation, including graphics, media, orcompute shader programs. The TD/IC logic 1523A-1523F performs localthread dispatch and thread control operations for the execution unitswithin a sub-core and facilitate communication between threads executingon the execution units of the sub-core. The 3D sampler 1525A-1525F canread texture or other 3D graphics related data into memory. The 3Dsampler can read texture data differently based on a configured samplestate and the texture format associated with a given texture. The mediasampler 1526A-1526F can perform similar read operations based on thetype and format associated with media data. For example, each graphicssub-core 1521A-1521F can alternately include a unified 3D and mediasampler. Threads executing on the execution units within each of thesub-cores 1521A-1521F can make use of shared local memory 1528A-1528Fwithin each sub-core, to enable threads executing within a thread groupto execute using a common pool of on-chip memory.

FIG. 15C is a block diagram of general-purpose graphics processing unit(GPGPU) 1570 that can be configured as a graphics processor, e.g., thegraphics processor 1508, and/or compute accelerator, according toembodiments described herein. The GPGPU 1570 can interconnect with hostprocessors (e.g., one or more CPU(s) 1546) and memory 1571, 1572 via oneor more system and/or memory busses. Memory 1571 may be system memorythat can be shared with the one or more CPU(s) 1546, while memory 1572is device memory that is dedicated to the GPGPU 1570. For example,components within the GPGPU 1570 and memory 1572 may be mapped intomemory addresses that are accessible to the one or more CPU(s) 1546.Access to memory 1571 and 1572 may be facilitated via a memorycontroller 1568. The memory controller 1568 may include an internaldirect memory access (DMA) controller 1569 or can include logic toperform operations that would otherwise be performed by a DMAcontroller.

The GPGPU 1570 includes multiple cache memories, including an L2 cache1553, L1 cache 1554, an instruction cache 1555, and shared memory 1556,at least a portion of which may also be partitioned as a cache memory.The GPGPU 1570 also includes multiple compute units 1560A-1560N. Eachcompute unit 1560A-1560N includes a set of vector registers 1561, scalarregisters 1562, vector logic units 1563, and scalar logic units 1564.The compute units 1560A-1560N can also include local shared memory 1565and a program counter 1566. The compute units 1560A-1560N can couplewith a constant cache 1567, which can be used to store constant data,which is data that cannot change during the run of kernel or shaderprogram that executes on the GPGPU 1570. The constant cache 1567 may bea scalar data cache and cached data can be fetched directly into thescalar registers 1562.

During operation, the one or more CPU(s) 1546 can write commands intoregisters or memory in the GPGPU 1570 that has been mapped into anaccessible address space. The command processors 1557 can read thecommands from registers or memory and determine how those commands canbe processed within the GPGPU 1570. A thread dispatcher 1558 can then beused to dispatch threads to the compute units 1560A-1560N to performthose commands. Each compute unit 1560A-1560N can execute threadsindependently of the other compute units. Additionally, each computeunit 1560A-1560N can be independently configured for conditionalcomputation and can conditionally output the results of computation tomemory. The command processors 1557 can interrupt the one or more CPU(s)1546 when the submitted commands are complete.

FIG. 16A-16C illustrate block diagrams of additional graphics processorand compute accelerator architectures provided by embodiments describedherein, e.g., in accordance with FIG. 15A-15C. The elements of FIG.16A-16C having the same or similar names as the elements of any otherfigure herein describe the same elements as in the other figures, canoperate or function in a manner similar to that, can comprise the samecomponents, and can be linked to other entities, as those describedelsewhere herein, but are not limited to such.

FIG. 16A is a block diagram of a graphics processor 1600, which may be adiscrete graphics processing unit, or may be a graphics processorintegrated with a plurality of processing cores, or other semiconductordevices such as, but not limited to, memory devices or networkinterfaces. The graphics processor 1600 may be a variant of the graphicsprocessor 1508 and may be used in place of the graphics processor 1508.Therefore, the discussion of any features in combination with thegraphics processor 1508 herein also discloses a correspondingcombination with the graphics processor 1600, but is not limited tosuch. The graphics processor may communicate via a memory mapped I/Ointerface to registers on the graphics processor and with commandsplaced into the processor memory. Graphics processor 1600 may include amemory interface 1614 to access memory. Memory interface 1614 can be aninterface to local memory, one or more internal caches, one or moreshared external caches, and/or to system memory.

Optionally, graphics processor 1600 also includes a display controller1602 to drive display output data to a display device 1618. Displaycontroller 1602 includes hardware for one or more overlay planes for thedisplay and composition of multiple layers of video or user interfaceelements. The display device 1618 can be an internal or external displaydevice. In one embodiment the display device 1618 is a head mounteddisplay device, such as a virtual reality (VR) display device or anaugmented reality (AR) display device. Graphics processor 1600 mayinclude a video codec engine 1606 to encode, decode, or transcode mediato, from, or between one or more media encoding formats, including, butnot limited to Moving Picture Experts Group (MPEG) formats such asMPEG-2, Advanced Video Coding (AVC) formats such as H.264/MPEG-4 AVC,H.265/HEVC, Alliance for Open Media (AOMedia) VP8, VP9, as well as theSociety of Motion Picture & Television Engineers (SMPTE) 421M/VC-1, andJoint Photographic Experts Group (JPEG) formats such as JPEG, and MotionJPEG (MJPEG) formats.

Graphics processor 1600 may include a block image transfer (BLIT) engine1603 to perform two-dimensional (2D) rasterizer operations including,for example, bit-boundary block transfers. However, alternatively, 2Dgraphics operations may be performed using one or more components ofgraphics processing engine (GPE) 1610. In some embodiments, GPE 1610 isa compute engine for performing graphics operations, includingthree-dimensional (3D) graphics operations and media operations.

GPE 1610 may include a 3D pipeline 1612 for performing 3D operations,such as rendering three-dimensional images and scenes using processingfunctions that act upon 3D primitive shapes (e.g., rectangle, triangle,etc.). The 3D pipeline 1612 includes programmable and fixed functionelements that perform various tasks within the element and/or spawnexecution threads to a 3D/Media subsystem 1615. While 3D pipeline 1612can be used to perform media operations, an embodiment of GPE 1610 alsoincludes a media pipeline 1616 that is specifically used to performmedia operations, such as video post-processing and image enhancement.

Media pipeline 1616 may include fixed function or programmable logicunits to perform one or more specialized media operations, such as videodecode acceleration, video de-interlacing, and video encode accelerationin place of, or on behalf of video codec engine 1606. Media pipeline1616 may additionally include a thread spawning unit to spawn threadsfor execution on 3D/Media subsystem 1615. The spawned threads performcomputations for the media operations on one or more graphics executionunits included in 3D/Media subsystem 1615.

The 3D/Media subsystem 1615 may include logic for executing threadsspawned by 3D pipeline 1612 and media pipeline 1616. The pipelines maysend thread execution requests to 3D/Media subsystem 1615, whichincludes thread dispatch logic for arbitrating and dispatching thevarious requests to available thread execution resources. The executionresources include an array of graphics execution units to process the 3Dand media threads. The 3D/Media subsystem 1615 may include one or moreinternal caches for thread instructions and data. Additionally, the3D/Media subsystem 1615 may also include shared memory, includingregisters and addressable memory, to share data between threads and tostore output data.

FIG. 16B illustrates a graphics processor 1620, being a variant of thegraphics processor 1600 and may be used in place of the graphicsprocessor 1600 and vice versa. Therefore, the discussion of any featuresin combination with the graphics processor 1600 herein also discloses acorresponding combination with the graphics processor 1620, but is notlimited to such. The graphics processor 1620 has a tiled architecture,according to embodiments described herein. The graphics processor 1620may include a graphics processing engine cluster 1622 having multipleinstances of the graphics processing engine 1610 of FIG. 16A within agraphics engine tile 1610A-1610D. Each graphics engine tile 1610A-1610Dcan be interconnected via a set of tile interconnects 1623A-1623F. Eachgraphics engine tile 1610A-1610D can also be connected to a memorymodule or memory device 1626A-1626D via memory interconnects1625A-1625D. The memory devices 1626A-1626D can use any graphics memorytechnology. For example, the memory devices 1626A-1626D may be graphicsdouble data rate (GDDR) memory. The memory devices 1626A-1626D may behigh-bandwidth memory (HBM) modules that can be on-die with theirrespective graphics engine tile 1610A-1610D. The memory devices1626A-1626D may be stacked memory devices that can be stacked on top oftheir respective graphics engine tile 1610A-1610D. Each graphics enginetile 1610A-1610D and associated memory 1626A-1626D may reside onseparate chiplets, which are bonded to a base die or base substrate, asdescribed in further detail in FIG. 24B-24D.

The graphics processor 1620 may be configured with a non-uniform memoryaccess (NUMA) system in which memory devices 1626A-1626D are coupledwith associated graphics engine tiles 1610A-1610D. A given memory devicemay be accessed by graphics engine tiles other than the tile to which itis directly connected. However, access latency to the memory devices1626A-1626D may be lowest when accessing a local tile. In oneembodiment, a cache coherent NUMA (ccNUMA) system is enabled that usesthe tile interconnects 1623A-1623F to enable communication between cachecontrollers within the graphics engine tiles 1610A-1610D to keep aconsistent memory image when more than one cache stores the same memorylocation.

The graphics processing engine cluster 1622 can connect with an on-chipor on-package fabric interconnect 1624. In one embodiment the fabricinterconnect 1624 includes a network processor, network on a chip (NoC),or another switching processor to enable the fabric interconnect 1624 toact as a packet switched fabric interconnect that switches data packetsbetween components of the graphics processor 1620. The fabricinterconnect 1624 can enable communication between graphics engine tiles1610A-1610D and components such as the video codec engine 1606 and oneor more copy engines 1604. The copy engines 1604 can be used to movedata out of, into, and between the memory devices 1626A-1626D and memorythat is external to the graphics processor 1620 (e.g., system memory).The fabric interconnect 1624 can also be used to interconnect thegraphics engine tiles 1610A-1610D. The graphics processor 1620 mayoptionally include a display controller 1602 to enable a connection withan external display device 1618. The graphics processor may also beconfigured as a graphics or compute accelerator. In the acceleratorconfiguration, the display controller 1602 and display device 1618 maybe omitted.

The graphics processor 1620 can connect to a host system via a hostinterface 1628. The host interface 1628 can enable communication betweenthe graphics processor 1620, system memory, and/or other systemcomponents. The host interface 1628 can be, for example, a PCI expressbus or another type of host system interface. For example, the hostinterface 1628 may be an NVLink or NVSwitch interface. The hostinterface 1628 and fabric interconnect 1624 can cooperate to enablemultiple instances of the graphics processor 1620 to act as singlelogical device. Cooperation between the host interface 1628 and fabricinterconnect 1624 can also enable the individual graphics engine tiles1610A-1610D to be presented to the host system as distinct logicalgraphics devices.

FIG. 16C illustrates a compute accelerator 1630, according toembodiments described herein. The compute accelerator 1630 can includearchitectural similarities with the graphics processor 1620 of FIG. 16Band is optimized for compute acceleration. A compute engine cluster 1632can include a set of compute engine tiles 1640A-1640D that includeexecution logic that is optimized for parallel or vector-basedgeneral-purpose compute operations. The compute engine tiles 1640A-1640Dmay not include fixed function graphics processing logic, although insome embodiments one or more of the compute engine tiles 1640A-1640D caninclude logic to perform media acceleration. The compute engine tiles1640A-1640D can connect to memory 1626A-1626D via memory interconnects1625A-1625D. The memory 1626A-1626D and memory interconnects 1625A-1625Dmay be similar technology as in graphics processor 1620, or can bedifferent. The graphics compute engine tiles 1640A-1640D can also beinterconnected via a set of tile interconnects 1623A-1623F and may beconnected with and/or interconnected by a fabric interconnect 1624. Inone embodiment the compute accelerator 1630 includes a large L3 cache1636 that can be configured as a device-wide cache. The computeaccelerator 1630 can also connect to a host processor and memory via ahost interface 1628 in a similar manner as the graphics processor 1620of FIG. 16B.

The compute accelerator 1630 can also include an integrated networkinterface 1642. In one embodiment the integrated network interface 1642includes a network processor and controller logic that enables thecompute engine cluster 1632 to communicate over a physical layerinterconnect 1644 without requiring data to traverse memory of a hostsystem. In one embodiment, one of the compute engine tiles 1640A-1640Dis replaced by network processor logic and data to be transmitted orreceived via the physical layer interconnect 1644 may be transmitteddirectly to or from memory 1626A-1626D. Multiple instances of thecompute accelerator 1630 may be joined via the physical layerinterconnect 1644 into a single logical device. Alternatively, thevarious compute engine tiles 1640A-1640D may be presented as distinctnetwork accessible compute accelerator devices.

Graphics Processing Engine

FIG. 17 is a block diagram of a graphics processing engine 1710 of agraphics processor in accordance with some embodiments. The graphicsprocessing engine (GPE) 1710 may be a version of the GPE 1610 shown inFIG. 16A, and may also represent a graphics engine tile 1610A-1610D ofFIG. 16B. The elements of FIG. 17 having the same or similar names asthe elements of any other figure herein describe the same elements as inthe other figures, can operate or function in a manner similar to that,can comprise the same components, and can be linked to other entities,as those described elsewhere herein, but are not limited to such. Forexample, the 3D pipeline 1612 and media pipeline 1616 of FIG. 16A arealso illustrated in FIG. 17 . The media pipeline 1616 is optional insome embodiments of the GPE 1710 and may not be explicitly includedwithin the GPE 1710. For example and in at least one embodiment, aseparate media and/or image processor is coupled to the GPE 1710.

GPE 1710 may couple with or include a command streamer 1703, whichprovides a command stream to the 3D pipeline 1612 and/or media pipelines1616. Alternatively or additionally, the command streamer 1703 may bedirectly coupled to a unified return buffer 1718. The unified returnbuffer 1718 may be communicatively coupled to a graphics core array1714. Optionally, the command streamer 1703 is coupled with memory,which can be system memory, or one or more of internal cache memory andshared cache memory. The command streamer 1703 may receive commands fromthe memory and sends the commands to 3D pipeline 1612 and/or mediapipeline 1616. The commands are directives fetched from a ring buffer,which stores commands for the 3D pipeline 1612 and media pipeline 1616.The ring buffer can additionally include batch command buffers storingbatches of multiple commands. The commands for the 3D pipeline 1612 canalso include references to data stored in memory, such as but notlimited to vertex and geometry data for the 3D pipeline 1612 and/orimage data and memory objects for the media pipeline 1616. The 3Dpipeline 1612 and media pipeline 1616 process the commands and data byperforming operations via logic within the respective pipelines or bydispatching one or more execution threads to the graphics core array1714. The graphics core array 1714 may include one or more blocks ofgraphics cores (e.g., graphics core(s) 1715A, graphics core(s) 1715B),each block including one or more graphics cores. Each graphics coreincludes a set of graphics execution resources that includesgeneral-purpose and graphics specific execution logic to performgraphics and compute operations, as well as fixed function textureprocessing and/or machine learning and artificial intelligenceacceleration logic.

In various embodiments the 3D pipeline 1612 can include fixed functionand programmable logic to process one or more shader programs, such asvertex shaders, geometry shaders, pixel shaders, fragment shaders,compute shaders, or other shader programs, by processing theinstructions and dispatching execution threads to the graphics corearray 1714. The graphics core array 1714 provides a unified block ofexecution resources for use in processing these shader programs.Multi-purpose execution logic (e.g., execution units) within thegraphics core(s) 1715A-1715B of the graphics core array 1714 includessupport for various 3D API shader languages and can execute multiplesimultaneous execution threads associated with multiple shaders.

The graphics core array 1714 may include execution logic to performmedia functions, such as video and/or image processing. The executionunits may include general-purpose logic that is programmable to performparallel general-purpose computational operations, in addition tographics processing operations. The general-purpose logic can performprocessing operations in parallel or in conjunction with general-purposelogic within the processor core(s) 1407 of FIG. 14 or core 1502A-1502Nas in FIG. 15A.

Output data generated by threads executing on the graphics core array1714 can output data to memory in a unified return buffer (URB) 1718.The URB 1718 can store data for multiple threads. The URB 1718 may beused to send data between different threads executing on the graphicscore array 1714. The URB 1718 may additionally be used forsynchronization between threads on the graphics core array 1714 andfixed function logic within the shared function logic 1720.

Optionally, the graphics core array 1714 may be scalable, such that thearray includes a variable number of graphics cores, each having avariable number of execution units based on the target power andperformance level of GPE 1710. The execution resources may bedynamically scalable, such that execution resources may be enabled ordisabled.

The graphics core array 1714 couples with shared function logic 1720that includes multiple resources that are shared between the graphicscores in the graphics core array. The shared functions within the sharedfunction logic 1720 are hardware logic units that provide specializedsupplemental functionality to the graphics core array 1714. In variousembodiments, shared function logic 1720 includes but is not limited tosampler 1721, math 1722, and inter-thread communication (ITC) 1723logic. Additionally, one or more cache(s) 1725 within the sharedfunction logic 1720 may be implemented.

A shared function is implemented at least in a case where the demand fora given specialized function is insufficient for inclusion within thegraphics core array 1714. Instead, a single instantiation of thatspecialized function is implemented as a stand-alone entity in theshared function logic 1720 and shared among the execution resourceswithin the graphics core array 1714. The precise set of functions thatare shared between the graphics core array 1714 and included within thegraphics core array 1714 varies across embodiments. Specific sharedfunctions within the shared function logic 1720 that are usedextensively by the graphics core array 1714 may be included withinshared function logic 1716 within the graphics core array 1714.Optionally, the shared function logic 1716 within the graphics corearray 1714 can include some or all logic within the shared functionlogic 1720. All logic elements within the shared function logic 1720 maybe duplicated within the shared function logic 1716 of the graphics corearray 1714. Alternatively, the shared function logic 1720 is excluded infavor of the shared function logic 1716 within the graphics core array1714.

Execution Units

FIG. 18A-18B illustrate thread execution logic 1800 including an arrayof processing elements employed in a graphics processor core accordingto embodiments described herein. The elements of FIG. 18A-18B having thesame or similar names as the elements of any other figure hereindescribe the same elements as in the other figures, can operate orfunction in a manner similar to that, can comprise the same components,and can be linked to other entities, as those described elsewhereherein, but are not limited to such. FIG. 18A-18B illustrates anoverview of thread execution logic 1800, which may be representative ofhardware logic illustrated with each sub-core 1521A-1521F of FIG. 15B.FIG. 18A is representative of an execution unit within a general-purposegraphics processor, while FIG. 18B is representative of an executionunit that may be used within a compute accelerator.

As illustrated in FIG. 18A, thread execution logic 1800 may include ashader processor 1802, a thread dispatcher 1804, instruction cache 1806,a scalable execution unit array including a plurality of graphicsexecution units 1808A 1808N, a sampler 1810, shared local memory 1811, adata cache 1812, and a data port 1814. Optionally, the scalableexecution unit array can dynamically scale by enabling or disabling oneor more execution units (e.g., any of graphics execution units 1808A,1808B, 1808C, 1808D, through 1808N-1 and 1808N) based on thecomputational requirements of a workload. The included components may beinterconnected via an interconnect fabric that links to each of thecomponents. Thread execution logic 1800 may include one or moreconnections to memory, such as system memory or cache memory, throughone or more of instruction cache 1806, data port 1814, sampler 1810, andgraphics execution units 1808A-1808N. Each execution unit (e.g., 1808A)may be a stand-alone programmable general-purpose computational unitthat is capable of executing multiple simultaneous hardware threadswhile processing multiple data elements in parallel for each thread. Invarious embodiments, the array of execution units 1808A-1808N isscalable to include any number individual execution units.

In some embodiments the graphics execution units 1808A-1808N may beprimarily used to execute shader programs. A shader processor 1802 canprocess the various shader programs and dispatch execution threadsassociated with the shader programs via a thread dispatcher 1804. Thethread dispatcher may include logic to arbitrate thread initiationrequests from the graphics and media pipelines and instantiate therequested threads on one or more execution units in the graphicsexecution units 1808A-1808N. For example, a geometry pipeline candispatch vertex, tessellation, or geometry shaders to the threadexecution logic for processing. Optionally, the thread dispatcher 1804can also process runtime thread spawning requests from the executingshader programs.

In some embodiments, the graphics execution units 1808A-1808N maysupport an instruction set that includes native support for manystandard 3D graphics shader instructions, such that shader programs fromgraphics libraries (e.g., Direct 3D and OpenGL) are executed with aminimal translation. The execution units support vertex and geometryprocessing (e.g., vertex programs, geometry programs, vertex shaders),pixel processing (e.g., pixel shaders, fragment shaders) andgeneral-purpose processing (e.g., compute and media shaders). Each ofthe graphics execution units 1808A-1808N is capable of multi-issuesingle instruction multiple data (SIMD) execution and multi-threadedoperation enables an efficient execution environment in the face ofhigher latency memory accesses. Each hardware thread within eachexecution unit has a dedicated high-bandwidth register file andassociated independent thread-state. Execution is multi-issue per clockto pipelines capable of integer, single and double precision floatingpoint operations, SIMD branch capability, logical operations,transcendental operations, and other miscellaneous operations. Whilewaiting for data from memory or one of the shared functions, dependencylogic within the execution units 1808A-1808N causes a waiting thread tosleep until the requested data has been returned. While the waitingthread is sleeping, hardware resources may be devoted to processingother threads. For example, during a delay associated with a vertexshader operation, an execution unit can perform operations for a pixelshader, fragment shader, or another type of shader program, including adifferent vertex shader, such as vertex shader 2107 illustrated in FIG.21 . Various embodiments can apply to use execution by use of SingleInstruction Multiple Thread (SIMT) as an alternate to use of SIMD or inaddition to use of SIMD. Reference to a SIMD core or operation can applyalso to SIMT or apply to SIMD in combination with SIMT.

Each execution unit in graphics execution units 1808A-1808N operates onarrays of data elements. The number of data elements is the “executionsize,” or the number of channels for the instruction. An executionchannel is a logical unit of execution for data element access, masking,and flow control within instructions. The number of channels may beindependent of the number of physical Arithmetic Logic Units (ALUs),Floating-Point Units (FPUs), or other logic units (e.g., tensor cores,ray tracing cores, etc.) for a particular graphics processor.Additionally, the graphics execution units 1808A-1808N may supportinteger and floating-point data types.

The execution unit instruction set includes SIMD instructions. Thevarious data elements can be stored as a packed data type in a registerand the execution unit can process the various elements based on thedata size of the elements. For example, when operating on a 256-bit widevector, the 256 bits of the vector are stored in a register and theexecution unit operates on the vector as four separate 64-bit packeddata elements (Quad-Word (QW) size data elements), eight separate 32-bitpacked data elements (Double Word (DW) size data elements), sixteenseparate 16-bit packed data elements (Word (W) size data elements), orthirty-two separate 8-bit data elements (byte (B) size data elements).However, different vector widths and register sizes are possible.

Optionally, one or more execution units can be combined into a fusedgraphics execution unit 1809A-1809N having thread control logic(1807A-1807N) that is common to the fused EUs. Multiple EUs can be fusedinto an EU group. Each EU in the fused EU group can be configured toexecute a separate SIMD hardware thread. The number of EUs in a fused EUgroup can vary according to embodiments. Additionally, various SIMDwidths can be performed per-EU, including but not limited to SIMD8,SIMD16, and SIMD32. Each fused graphics execution unit 1809A-1809Nincludes at least two execution units. For example, fused execution unit1809A includes a first EU 1808A, second EU 1808B, and thread controllogic 1807A that is common to the first EU 1808A and the second EU1808B. The thread control logic 1807A controls threads executed on thefused graphics execution unit 1809A, allowing each EU within the fusedexecution units 1809A-1809N to execute using a common instructionpointer register.

One or more internal instruction caches (e.g., 1806) are included in thethread execution logic 1800 to cache thread instructions for theexecution units. One or more data caches (e.g., 1812) may be included inthe thread execution logic 1800 to cache thread data during threadexecution. Threads executing on the execution logic 1800 can also storeexplicitly managed data in the shared local memory 1811. A sampler 1810may be included to provide texture sampling for 3D operations and mediasampling for media operations. sampler 1810 may include specializedtexture or media sampling functionality to process texture or media dataduring the sampling process before providing the sampled data to anexecution unit.

During execution, the graphics and media pipelines send threadinitiation requests to thread execution logic 1800 via thread spawningand dispatch logic. Once a group of geometric objects has been processedand rasterized into pixel data, pixel processor logic (e.g., pixelshader logic, fragment shader logic, etc.) within the shader processor1802 is invoked to further compute output information and cause resultsto be written to output surfaces (e.g., color buffers, depth buffers,stencil buffers, etc.). A pixel shader or fragment shader may calculatethe values of the various vertex attributes that are to be interpolatedacross the rasterized object. The pixel processor logic within theshader processor 1802 may then execute an application programminginterface (API)-supplied pixel or fragment shader program. To executethe shader program, the shader processor 1802 dispatches threads to anexecution unit (e.g., 1808A) via thread dispatcher 1804. Shaderprocessor 1802 may use texture sampling logic in the sampler 1810 toaccess texture data in texture maps stored in memory. Arithmeticoperations on the texture data and the input geometry data compute pixelcolor data for each geometric fragment, or discards one or more pixelsfrom further processing.

In addition, the data port 1814 may provide a memory access mechanismfor the thread execution logic 1800 to output processed data to memoryfor further processing on a graphics processor output pipeline. The dataport 1814 may include or couple to one or more cache memories (e.g.,data cache 1812) to cache data for memory access via the data port 1814.

Optionally, the execution logic 1800 can also include a ray tracer 1805that can provide ray tracing acceleration functionality. The ray tracer1805 can support a ray tracing instruction set that includesinstructions/functions for ray generation. The ray tracing instructionset can be similar to or different from the ray-tracing instruction setsupported by the ray tracing cores 372 in FIG. 3C.

FIG. 18B illustrates example internal details of an execution unit 1808.A graphics execution unit 1808 can include an instruction fetch unit1837, a general register file (GRF) array 1824, an architecturalregister file array (ARF) 1826, a thread arbiter 1822, a send unit 1830,a branch unit 1832, a set of SIMD floating point units (FPUs) 1834, andoptionally a set of dedicated integer SIMD ALUs 1835. The GRF 1824 andARF 1826 includes the set of general register files and architectureregister files associated with each simultaneous hardware thread thatmay be active in the graphics execution unit 1808. Per threadarchitectural state may be maintained in the ARF 1826, while data usedduring thread execution is stored in the GRF 1824. The execution stateof each thread, including the instruction pointers for each thread, canbe held in thread-specific registers in the ARF 1826.

The graphics execution unit 1808 may have an architecture that is acombination of Simultaneous Multi-Threading (SMT) and fine-grainedInterleaved Multi-Threading (IMT). The architecture may have a modularconfiguration that can be fine-tuned at design time based on a targetnumber of simultaneous threads and number of registers per executionunit, where execution unit resources are divided across logic used toexecute multiple simultaneous threads. The number of logical threadsthat may be executed by the graphics execution unit 1808 is not limitedto the number of hardware threads, and multiple logical threads can beassigned to each hardware thread.

Optionally, the graphics execution unit 1808 can co-issue multipleinstructions, which may each be different instructions. The threadarbiter 1822 of the graphics execution unit 1808 can dispatch theinstructions to one of the send unit 1830, branch unit 1832, or SIMDFPU(s) 1834 for execution. Each execution thread can access 128general-purpose registers within the GRF 1824, where each register canstore 32 bytes, accessible as a SIMD 8-element vector of 32-bit dataelements. Each execution unit thread may have access to 4 Kbytes withinthe GRF 1824, although embodiments are not so limited, and greater orfewer register resources may be provided in other embodiments. Thegraphics execution unit 1808 may be partitioned into seven hardwarethreads that can independently perform computational operations,although the number of threads per execution unit can also varyaccording to embodiments, for example, up to 16 hardware threads may besupported. In an example embodiment, in which seven threads may access 4Kbytes, the GRF 1824 can store a total of 28 Kbytes. In another exampleembodiment, where 16 threads may access 4 Kbytes, the GRF 1824 can storea total of 64 Kbytes. The number of threads per execution unit are,however, not limited to those examples and may be more or less than thegiven numbers. Flexible addressing modes can permit registers to beaddressed together to build effectively wider registers or to representstrided rectangular block data structures.

Additionally or alternatively, memory operations, sampler operations,and other longer-latency system communications may be dispatched via“send” instructions that are executed by the message passing send unit1830. Branch instructions may be dispatched to a dedicated branch unit1832 to facilitate SIMD divergence and eventual convergence.

The graphics execution unit 1808 may include one or more SIMD floatingpoint units (FPU(s)) 1834 to perform floating-point operations. TheFPU(s) 1834 may also support integer computation. In some instances, theFPU(s) 1834 can SIMD execute up to M number of 32-bit floating-point (orinteger) operations, or SIMD execute up to 2M 16-bit integer or 16-bitfloating-point operations. Optionally, at least one of the FPU(s)provides extended math capability to support high-throughputtranscendental math functions and double precision 64-bitfloating-point. A set of 8-bit integer SIMD ALUs 1835 may also bepresent, and may be specifically optimized to perform operationsassociated with machine learning computations.

Optionally, arrays of multiple instances of the graphics execution unit1808 can be instantiated in a graphics sub-core grouping (e.g., asub-slice). For scalability, product architects can choose the exactnumber of execution units per sub-core grouping. The execution unit 1808may execute instructions across a plurality of execution channels. Inaddition, each thread executed on the graphics execution unit 1808 maybe executed on a different channel.

FIG. 19 illustrates a further example execution unit 1900. The elementsof FIG. 19 having the same or similar names as the elements of any otherfigure herein describe the same elements as in the other figures, canoperate or function in a manner similar to that, can comprise the samecomponents, and can be linked to other entities, as those describedelsewhere herein, but are not limited to such. The execution unit 1900may be a compute-optimized execution unit for use in, for example, acompute engine tile 1640A-1640D as in FIG. 16C, but is not limited assuch. The execution unit 1900 may also be used in a graphics engine tile1610A-1610D as in FIG. 16B. The execution unit 1900 may include a threadcontrol unit 1901, a thread state unit 1902, an instructionfetch/prefetch unit 1903, and an instruction decode unit 1904. Theexecution unit 1900 may additionally include a register file 1906 thatstores registers that can be assigned to hardware threads within theexecution unit. The execution unit 1900 may additionally include a sendunit 1907 and a branch unit 1908. The send unit 1907 and branch unit1908 may operate similarly as the send unit 1830 and a branch unit 1832of the graphics execution unit 1808 of FIG. 18B.

The execution unit 1900 can also include a compute unit 1910 thatincludes multiple different types of functional units. The compute unit1910 may also include an ALU 1911, a systolic array 1912, and a mathunit 1913. The ALU 1911 includes an array of arithmetic logic units. TheALU 1911 can be configured to perform 64-bit, 32-bit, and 16-bit integerand floating-point operations across multiple processing lanes and datachannels and for multiple hardware and/or software threads. The ALU 1911can perform integer and floating-point operations simultaneously (e.g.,within the same clock cycle).

The systolic array 1912 includes a W wide and D deep network of dataprocessing units that can be used to perform vector or otherdata-parallel operations in a systolic manner. The systolic array 1912can be configured to perform various matrix operations, including as dotproduct, outer product, and general matrix-matrix multiplication (GEMM)operations. The systolic array 1912 may support 16-bit floating pointoperations, as well as 8-bit, 4-bit, 2-bit, and binary integeroperations. The systolic array 1912 may be configured to acceleratemachine learning operations. The systolic array 1912 can be configuredwith support for bfloat16, (brain floating point) 16-bit floating pointformat or a tensor float 32-bit floating point format (TF32) that havedifferent numbers of mantissa and exponent bits relative to Institute ofElectrical and Electronics Engineers (IEEE) 754 formats. FP64 formatscan also be supported.

In one embodiment, the systolic array 1912 includes hardware toaccelerate sparse matrix operations. Multiplication operations forsparse regions of input data can be bypassed without sacrificingthroughput. Block sparsity within input matrices can be detected andoperations having known output values can be bypassed. In oneembodiment, the systolic array 1912 includes hardware to enableoperations on sparse data having a compressed representation. Acompressed representation of a sparse matrix stores non-zero values andmetadata that defines the position of the non-zero values within thematrix. Example compressed representations include but are not limitedto compressed tensor representations such as compressed sparse row(CSR), compressed sparse column (CSC), compressed sparse fiber (CSF)representations. Support for compressed representations enableoperations to be performed on input in a compressed tensor formatwithout requiring the compressed representation to be decompressed ordecoded. In such embodiment, operations can be performed on non-zeroinput values and the resulting non-zero output values can be mapped intoan output matrix. In some embodiments, hardware support is also providedfor machine-specific lossless data compression formats that are usedwhen transmitting data within hardware or across system busses. Suchdata may be retained in a compressed format for sparse input data andthe systolic array 1912 can used the compression metadata for thecompressed data to enable operations to be performed on non-zero values,or to enable blocks of zero data input to be bypassed for multiplyoperations.

The math unit 1913 can be configured to perform a specific subset ofmathematical operations in an efficient and lower-power manner than thenALU unit 1911. The math unit 1913 can include math logic found in sharedfunction logic of a graphics processing engine provided by otherembodiments described, e.g., the math logic 1722 of the shared functionlogic 1720 of FIG. 17 . The math unit 1913 can be configured to perform32-bit and 64-bit floating point operations.

The thread control unit 1901 includes logic to control the execution ofthreads within the execution unit. The thread control unit 1901 caninclude thread arbitration logic to start, stop, and preempt executionof threads within the execution unit 1900. The thread state unit 1902can be used to store thread state for threads assigned to execute on theexecution unit 1900. Storing the thread state within the execution unit1900 enables the rapid pre-emption of threads when those threads becomeblocked or idle. The instruction fetch/prefetch unit 1903 can fetchinstructions from an instruction cache of higher-level execution logic(e.g., instruction cache 1806 as in FIG. 18A). The instructionfetch/prefetch unit 1903 can also issue prefetch requests forinstructions to be loaded into the instruction cache based on ananalysis of currently executing threads. The instruction decode unit1904 can be used to decode instructions to be executed by the computeunits. The instruction decode unit 1904 can be used as a secondarydecoder to decode complex instructions into constituentmicro-operations.

The execution unit 1900 additionally includes a register file 1906 thatcan be used by hardware threads executing on the execution unit 1900.Registers in the register file 1906 can be divided across the logic usedto execute multiple simultaneous threads within the compute unit 1910 ofthe execution unit 1900. The number of logical threads that may beexecuted by the graphics execution unit 1900 is not limited to thenumber of hardware threads, and multiple logical threads can be assignedto each hardware thread. The size of the register file 1906 can varyacross embodiments based on the number of supported hardware threads.Register renaming may be used to dynamically allocate registers tohardware threads.

FIG. 20 is a block diagram illustrating graphics processor instructionformats 2000. The graphics processor execution units support aninstruction set having instructions in multiple formats. The solid linedboxes illustrate the components that are generally included in anexecution unit instruction, while the dashed lines include componentsthat are optional or that are included in a sub-set of the instructions.In some embodiments the graphics processor instruction formats 2000described and illustrated are macro-instructions, in that they areinstructions supplied to the execution unit, as opposed tomicro-operations resulting from instruction decode once the instructionis processed. Thus, a single instructions may cause hardware to performmultiple micro-operations

The graphics processor execution units as described herein may nativelysupport instructions in a 128-bit instruction format 2010. A 64-bitcompacted instruction format 2030 is available for some instructionsbased on the selected instruction, instruction options, and number ofoperands. The native 128-bit instruction format 2010 provides access toall instruction options, while some options and operations arerestricted in the 64-bit format 2030. The native instructions availablein the 64-bit format 2030 vary by embodiment. The instruction iscompacted in part using a set of index values in an index field 2013.The execution unit hardware references a set of compaction tables basedon the index values and uses the compaction table outputs to reconstructa native instruction in the 128-bit instruction format 2010. Other sizesand formats of instruction can be used.

For each format, instruction opcode 2012 defines the operation that theexecution unit is to perform. The execution units execute eachinstruction in parallel across the multiple data elements of eachoperand. For example, in response to an add instruction the executionunit performs a simultaneous add operation across each color channelrepresenting a texture element or picture element. By default, theexecution unit performs each instruction across all data channels of theoperands. Instruction control field 2014 may enable control over one ormore execution options, such as channels selection (e.g., predication)and data channel order (e.g., swizzle). For instructions in the 128-bitinstruction format 2010 an exec-size field 2016 limits the number ofdata channels that can be executed in parallel. An exec-size field 2016may not be available for use in the 64-bit compact instruction format2030.

Some execution unit instructions have up to three operands including twosource operands, src0 2020, src1 2022, and one destination operand (dest2018). Other instructions, such as, for example, data manipulationinstructions, dot product instructions, multiply-add instructions, ormultiply-accumulate instructions, can have a third source operand (e.g.,SRC2 2024). The instruction opcode 2012 determines the number of sourceoperands. An instruction's last source operand can be an immediate(e.g., hard-coded) value passed with the instruction. The executionunits may also support multiple destination instructions, where one ormore of the destinations is implied or implicit based on the instructionand/or the specified destination.

The 128-bit instruction format 2010 may include an access/address modefield 2026 specifying, for example, whether direct register addressingmode or indirect register addressing mode is used. When direct registeraddressing mode is used, the register address of one or more operands isdirectly provided by bits in the instruction.

The 128-bit instruction format 2010 may also include an access/addressmode field 2026, which specifies an address mode and/or an access modefor the instruction. The access mode may be used to define a data accessalignment for the instruction. Access modes including a 16-byte alignedaccess mode and a 1-byte aligned access mode may be supported, where thebyte alignment of the access mode determines the access alignment of theinstruction operands. For example, when in a first mode, the instructionmay use byte-aligned addressing for source and destination operands andwhen in a second mode, the instruction may use 16-byte-alignedaddressing for all source and destination operands.

The address mode portion of the access/address mode field 2026 maydetermine whether the instruction is to use direct or indirectaddressing. When direct register addressing mode is used bits in theinstruction directly provide the register address of one or moreoperands. When indirect register addressing mode is used, the registeraddress of one or more operands may be computed based on an addressregister value and an address immediate field in the instruction.

Instructions may be grouped based on opcode 2012 bit-fields to simplifyOpcode decode 2040. For an 8-bit opcode, bits 4, 5, and 6 allow theexecution unit to determine the type of opcode. The precise opcodegrouping shown is merely an example. A move and logic opcode group 2042may include data movement and logic instructions (e.g., move (mov),compare (cmp)). Move and logic group 2042 may share the five leastsignificant bits (LSB), where move (mov) instructions are in the form of0000xxxxb and logic instructions are in the form of 0001xxxxb. A flowcontrol instruction group 2044 (e.g., call, jump (jmp)) includesinstructions in the form of 0010xxxxb (e.g., 0×20). A miscellaneousinstruction group 2046 includes a mix of instructions, includingsynchronization instructions (e.g., wait, send) in the form of 0011xxxxb(e.g., 0×30). A parallel math instruction group 2048 includescomponent-wise arithmetic instructions (e.g., add, multiply (mul)) inthe form of 0100xxxxb (e.g., 0×40). The parallel math instruction group2048 performs the arithmetic operations in parallel across datachannels. The vector math group 2050 includes arithmetic instructions(e.g., dp4) in the form of 0101xxxxb (e.g., 0×50). The vector math groupperforms arithmetic such as dot product calculations on vector operands.The illustrated opcode decode 2040, in one embodiment, can be used todetermine which portion of an execution unit can be used to execute adecoded instruction. For example, some instructions may be designated assystolic instructions that can be performed by a systolic array. Otherinstructions, such as ray-tracing instructions (not shown) can be routedto a ray-tracing core or ray-tracing logic within a slice or partitionof execution logic.

Graphics Pipeline

FIG. 21 is a block diagram of graphics processor 2100, according toanother embodiment. The elements of FIG. 21 having the same or similarnames as the elements of any other figure herein describe the sameelements as in the other figures, can operate or function in a mannersimilar to that, can comprise the same components, and can be linked toother entities, as those described elsewhere herein, but are not limitedto such.

The graphics processor 2100 may include different types of graphicsprocessing pipelines, such as a geometry pipeline 2120, a media pipeline2130, a display engine 2140, thread execution logic 2150, and a renderoutput pipeline 2170. Graphics processor 2100 may be a graphicsprocessor within a multi-core processing system that includes one ormore general-purpose processing cores. The graphics processor may becontrolled by register writes to one or more control registers (notshown) or via commands issued to graphics processor 2100 via a ringinterconnect 2102 Ring interconnect 2102 may couple graphics processor2100 to other processing components, such as other graphics processorsor general-purpose processors. Commands from ring interconnect 2102 areinterpreted by a command streamer 2103, which supplies instructions toindividual components of the geometry pipeline 2120 or the mediapipeline 2130.

Command streamer 2103 may direct the operation of a vertex fetcher 2105that reads vertex data from memory and executes vertex-processingcommands provided by command streamer 2103. The vertex fetcher 2105 mayprovide vertex data to a vertex shader 2107, which performs coordinatespace transformation and lighting operations to each vertex. Vertexfetcher 2105 and vertex shader 2107 may execute vertex-processinginstructions by dispatching execution threads to execution units2152A-2152B via a thread dispatcher 2131.

The execution units 2152A-2152B may be an array of vector processorshaving an instruction set for performing graphics and media operations.The execution units 2152A-2152B may have an attached L1 cache 2151 thatis specific for each array or shared between the arrays. The cache canbe configured as a data cache, an instruction cache, or a single cachethat is partitioned to contain data and instructions in differentpartitions.

A geometry pipeline 2120 may include tessellation components to performhardware-accelerated tessellation of 3D objects. A programmable hullshader 2111 may configure the tessellation operations. A programmabledomain shader 2117 may provide back-end evaluation of tessellationoutput. A tessellator 2113 may operate at the direction of hull shader2111 and contain special purpose logic to generate a set of detailedgeometric objects based on a coarse geometric model that is provided asinput to geometry pipeline 2120. In addition, if tessellation is notused, tessellation components (e.g., hull shader 2111, tessellator 2113,and domain shader 2117) can be bypassed. The tessellation components canoperate based on data received from the vertex shader 2107.

Complete geometric objects may be processed by a geometry shader 2119via one or more threads dispatched to execution units 2152A-2152B, orcan proceed directly to the clipper 2129. The geometry shader mayoperate on geometric objects, rather than vertices or patches ofvertices as in previous stages of the graphics pipeline. If thetessellation is disabled the geometry shader 2119 receives input fromthe vertex shader 2107. The geometry shader 2119 may be programmable bya geometry shader program to perform geometry tessellation if thetessellation units are disabled.

Before rasterization, a clipper 2129 processes vertex data. The clipper2129 may be a fixed function clipper or a programmable clipper havingclipping and geometry shader functions. A rasterizer and depth testcomponent 2173 in the render output pipeline 2170 may dispatch pixelshaders to convert the geometric objects into per pixel representations.The pixel shader logic may be included in thread execution logic 2150.Optionally, an application can bypass the rasterizer and depth testcomponent 2173 and access un-rasterized vertex data via a stream outunit 2123.

The graphics processor 2100 has an interconnect bus, interconnectfabric, or some other interconnect mechanism that allows data andmessage passing amongst the components of the processor. In someembodiments, execution units 2152A-2152B and associated logic units(e.g., L1 cache 2151, sampler 2154, texture cache 2158, etc.)interconnect via a data port 2156 to perform memory access andcommunicate with render output pipeline components of the processor. Asampler 2154, caches 2151, 2158 and execution units 2152A-2152B each mayhave separate memory access paths. Optionally, the texture cache 2158can also be configured as a sampler cache.

The render output pipeline 2170 may contain a rasterizer and depth testcomponent 2173 that converts vertex-based objects into an associatedpixel-based representation. The rasterizer logic may include awindower/masker unit to perform fixed function triangle and linerasterization. An associated render cache 2178 and depth cache 2179 arealso available in some embodiments. A pixel operations component 2177performs pixel-based operations on the data, though in some instances,pixel operations associated with 2D operations (e.g., bit block imagetransfers with blending) are performed by the 2D engine 2141, orsubstituted at display time by the display controller 2143 using overlaydisplay planes. A shared L3 cache 2175 may be available to all graphicscomponents, allowing the sharing of data without the use of main systemmemory.

The media pipeline 2130 may include a media engine 2137 and a videofront-end 2134. Video front-end 2134 may receive pipeline commands fromthe command streamer 2103. The media pipeline 2130 may include aseparate command streamer. Video front-end 2134 may process mediacommands before sending the command to the media engine 2137. Mediaengine 2137 may include thread spawning functionality to spawn threadsfor dispatch to thread execution logic 2150 via thread dispatcher 2131.

The graphics processor 2100 may include a display engine 2140. Thisdisplay engine 2140 may be external to processor 2100 and may couplewith the graphics processor via the ring interconnect 2102, or someother interconnect bus or fabric. Display engine 2140 may include a 2Dengine 2141 and a display controller 2143. Display engine 2140 maycontain special purpose logic capable of operating independently of the3D pipeline. Display controller 2143 may couple with a display device(not shown), which may be a system integrated display device, as in alaptop computer, or an external display device attached via a displaydevice connector.

The geometry pipeline 2120 and media pipeline 2130 maybe configurable toperform operations based on multiple graphics and media programminginterfaces and are not specific to any one application programminginterface (API). A driver software for the graphics processor maytranslate API calls that are specific to a particular graphics or medialibrary into commands that can be processed by the graphics processor.Support may be provided for the Open Graphics Library (OpenGL), OpenComputing Language (OpenCL), and/or Vulkan graphics and compute API, allfrom the Khronos Group. Support may also be provided for the Direct3Dlibrary from the Microsoft Corporation. A combination of these librariesmay be supported. Support may also be provided for the Open SourceComputer Vision Library (OpenCV). A future API with a compatible 3Dpipeline would also be supported if a mapping can be made from thepipeline of the future API to the pipeline of the graphics processor.

Graphics Pipeline Programming

FIG. 22A is a block diagram illustrating a graphics processor commandformat 2200 used for programming graphics processing pipelines, such as,for example, the pipelines described herein in conjunction with FIG.16A, 17, 21 . FIG. 22B is a block diagram illustrating a graphicsprocessor command sequence 2210 according to an embodiment. The solidlined boxes in FIG. 22A illustrate the components that are generallyincluded in a graphics command while the dashed lines include componentsthat are optional or that are included in a sub-set of the graphicscommands. The example graphics processor command format 2200 of FIG. 22Aincludes data fields to identify a client 2202, a command operation code(opcode) 2204, and data 2206 for the command. A sub-opcode 2205 and acommand size 2208 are also included in some commands.

Client 2202 may specify the client unit of the graphics device thatprocesses the command data. A graphics processor command parser mayexamine the client field of each command to condition the furtherprocessing of the command and route the command data to the appropriateclient unit. The graphics processor client units may include a memoryinterface unit, a render unit, a 2D unit, a 3D unit, and a media unit.Each client unit may have a corresponding processing pipeline thatprocesses the commands. Once the command is received by the client unit,the client unit reads the opcode 2204 and, if present, sub-opcode 2205to determine the operation to perform. The client unit performs thecommand using information in data field 2206. For some commands anexplicit command size 2208 is expected to specify the size of thecommand. The command parser may automatically determine the size of atleast some of the commands based on the command opcode. Commands may bealigned via multiples of a double word. Other command formats can alsobe used.

The flow diagram in FIG. 22B illustrates an example graphics processorcommand sequence 2210. Software or firmware of a data processing systemthat features an example graphics processor may use a version of thecommand sequence shown to set up, execute, and terminate a set ofgraphics operations. A sample command sequence is shown and describedfor purposes of example and is not limited to these specific commands orto this command sequence. Moreover, the commands may be issued as batchof commands in a command sequence, such that the graphics processor canprocess the sequence of commands in at least partially concurrence.

The graphics processor command sequence 2210 may begin with a pipelineflush command 2212 to cause any active graphics pipeline to complete thecurrently pending commands for the pipeline. Optionally, the 3D pipeline2222 and the media pipeline 2224 may not operate concurrently. Thepipeline flush is performed to cause the active graphics pipeline tocomplete any pending commands. In response to a pipeline flush, thecommand parser for the graphics processor can pause command processinguntil the active drawing engines complete pending operations and therelevant read caches are invalidated. Optionally, any data in the rendercache that is marked ‘dirty’ can be flushed to memory. Pipeline flushcommand 2212 can be used for pipeline synchronization or before placingthe graphics processor into a low power state.

A pipeline select command 2213 may be used when a command sequencerequests the graphics processor to explicitly switch between pipelines.A pipeline select command 2213 may be utilized once within an executioncontext before issuing pipeline commands unless the context is to issuecommands for both pipelines. A pipeline flush command 2212 may beutilized immediately before a pipeline switch via the pipeline selectcommand 2213.

A pipeline control command 2214 may configure a graphics pipeline foroperation and may be used to program the 3D pipeline 2222 and the mediapipeline 2224. The pipeline control command 2214 may configure thepipeline state for the active pipeline. The pipeline control command2214 may be used for pipeline synchronization and to clear data from oneor more cache memories within the active pipeline before processing abatch of commands.

Commands related to the return buffer state 2216 may be used toconfigure a set of return buffers for the respective pipelines to writedata. Some pipeline operations utilize the allocation, selection, orconfiguration of one or more return buffers into which the operationswrite intermediate data during processing. The graphics processor mayalso use one or more return buffers to store output data and to performcross thread communication. The return buffer state 2216 may includeselecting the size and number of return buffers to use for a set ofpipeline operations.

The remaining commands in the command sequence differ based on theactive pipeline for operations. Based on a pipeline determination 2220,the command sequence is tailored to the 3D pipeline 2222 beginning withthe 3D pipeline state 2230 or the media pipeline 2224 beginning at themedia pipeline state 2240.

The commands to configure the 3D pipeline state 2230 include 3D statesetting commands for vertex buffer state, vertex element state, constantcolor state, depth buffer state, and other state variables that are tobe configured before 3D primitive commands are processed. The values ofthese commands are determined at least in part based on the particular3D API in use. The 3D pipeline state 2230 commands may also be able toselectively disable or bypass one or more pipeline elements if thoseelements cannot be used.

A 3D primitive 2232 command may be used to submit 3D primitives to beprocessed by the 3D pipeline. Commands and associated parameters thatare passed to the graphics processor via the 3D primitive 2232 commandare forwarded to the vertex fetch function in the graphics pipeline. Thevertex fetch function uses the 3D primitive 2232 command data togenerate vertex data structures. The vertex data structures are storedin one or more return buffers. The 3D primitive 2232 command may be usedto perform vertex operations on 3D primitives via vertex shaders. Toprocess vertex shaders, 3D pipeline 2222 dispatches shader executionthreads to graphics processor execution units.

The 3D pipeline 2222 may be triggered via an execute 2234 command orevent. A register may write trigger command executions. An execution maybe triggered via a ‘go’ or ‘kick’ command in the command sequence.Command execution may be triggered using a pipeline synchronizationcommand to flush the command sequence through the graphics pipeline. The3D pipeline can perform geometry processing for the 3D primitives. Onceoperations are complete, the resulting geometric objects are rasterizedand the pixel engine colors the resulting pixels. Additional commands tocontrol pixel shading and pixel back end operations may also be includedfor those operations.

The graphics processor command sequence 2210 may follow the mediapipeline 2224 path when performing media operations. In general, thespecific use and manner of programming for the media pipeline 2224depends on the media or compute operations to be performed. Specificmedia decode operations may be offloaded to the media pipeline duringmedia decode. The media pipeline can also be bypassed and media decodecan be performed in whole or in part using resources provided by one ormore general-purpose processing cores. The media pipeline may alsoinclude elements for general-purpose graphics processor unit (GPGPU)operations, where the graphics processor is used to perform SIMD vectoroperations using computational shader programs that are not explicitlyrelated to the rendering of graphics primitives.

Media pipeline 2224 may be configured in a similar manner as the 3Dpipeline 2222. A set of commands to configure the media pipeline state2240 are dispatched or placed into a command queue before the mediaobject commands 2242. Commands for the media pipeline state 2240 mayinclude data to configure the media pipeline elements that can be usedto process the media objects. This includes data to configure the videodecode and video encode logic within the media pipeline, such as encodeor decode format. Commands for the media pipeline state 2240 may alsosupport the use of one or more pointers to “indirect” state elementsthat contain a batch of state settings.

Media object commands 2242 may supply pointers to media objects forprocessing by the media pipeline. The media objects include memorybuffers containing video data to be processed. Optionally, all mediapipeline states should be valid before issuing a media object command2242. Once the pipeline state is configured and media object commands2242 are queued, the media pipeline 2224 is triggered via an executecommand 2244 or an equivalent execute event (e.g., register write).Output from media pipeline 2224 may then be post processed by operationsprovided by the 3D pipeline 2222 or the media pipeline 2224. GPGPUoperations may be configured and executed in a similar manner as mediaoperations.

Graphics Software Architecture

FIG. 23 illustrates an example graphics software architecture for a dataprocessing system 2300. Such a software architecture may include a 3Dgraphics application 2310, an operating system 2320, and at least oneprocessor 2330. Processor 2330 may include a graphics processor 2332 andone or more general-purpose processor core(s) 2334. The processor 2330may be a variant of the processor 1402 or any other of the processorsdescribed herein. The processor 2330 may be used in place of theprocessor 1402 or any other of the processors described herein.Therefore, the discussion of any features in combination with theprocessor 1402 or any other of the processors described herein alsodiscloses a corresponding combination with the graphics processor 2332,but is not limited to such. Moreover, the elements of FIG. 23 having thesame or similar names as the elements of any other figure hereindescribe the same elements as in the other figures, can operate orfunction in a manner similar to that, can comprise the same components,and can be linked to other entities, as those described elsewhereherein, but are not limited to such. The graphics application 2310 andoperating system 2320 are each executed in the system memory 2350 of thedata processing system.

3D graphics application 2310 may contain one or more shader programsincluding shader instructions 2312. The shader language instructions maybe in a high-level shader language, such as the High-Level ShaderLanguage (HLSL) of Direct3D, the OpenGL Shader Language (GLSL), and soforth. The application may also include executable instructions 2314 ina machine language suitable for execution by the general-purposeprocessor core 2334. The application may also include graphics objects2316 defined by vertex data.

The operating system 2320 may be a Microsoft® Windows® operating systemfrom the Microsoft Corporation, a proprietary UNIX-like operatingsystem, or an open source UNIX-like operating system using a variant ofthe Linux kernel. The operating system 2320 can support a graphics API2322 such as the Direct3D API, the OpenGL API, or the Vulkan API. Whenthe Direct3D API is in use, the operating system 2320 uses a front-endshader compiler 2324 to compile any shader instructions 2312 in HLSLinto a lower-level shader language. The compilation may be ajust-in-time (JIT) compilation or the application can perform shaderpre-compilation. High-level shaders may be compiled into low-levelshaders during the compilation of the 3D graphics application 2310. Theshader instructions 2312 may be provided in an intermediate form, suchas a version of the Standard Portable Intermediate Representation (SPIR)used by the Vulkan API.

User mode graphics driver 2326 may contain a back-end shader compiler2327 to convert the shader instructions 2312 into a hardware specificrepresentation. When the OpenGL API is in use, shader instructions 2312in the GLSL high-level language are passed to a user mode graphicsdriver 2326 for compilation. The user mode graphics driver 2326 may useoperating system kernel mode functions 2328 to communicate with a kernelmode graphics driver 2329. The kernel mode graphics driver 2329 maycommunicate with graphics processor 2332 to dispatch commands andinstructions.

IP Core Implementations

One or more aspects may be implemented by representative code stored ona machine-readable medium (e.g., a non-transitory computer-readable (ormachine-readable) storage medium) that represents and/or defines logicwithin an integrated circuit such as a processor. For example, themachine-readable medium may include instructions which represent variouslogic within the processor. When read by a machine, the instructions maycause the machine to fabricate the logic to perform the techniquesdescribed herein. Such representations, known as “IP cores,” arereusable units of logic for an integrated circuit that may be stored ona tangible, machine-readable medium as a hardware model that describesthe structure of the integrated circuit. The hardware model may besupplied to various customers or manufacturing facilities, which loadthe hardware model on fabrication machines that manufacture theintegrated circuit. The integrated circuit may be fabricated such thatthe circuit performs operations described in association with any of theembodiments described herein.

FIG. 24A is a block diagram illustrating an IP core development system2400 that may be used to manufacture an integrated circuit to performoperations according to an embodiment. The IP core development system2400 may be used to generate modular, re-usable designs that can beincorporated into a larger design or used to construct an integratedcircuit (e.g., an SOC integrated circuit). A design facility 2430 cangenerate a software simulation 2410 of an IP core design in a high-levelprogramming language (e.g., C/C++). The software simulation 2410 can beused to design, test, and verify the behavior of the IP core using asimulation model 2412. The simulation model 2412 may include functional,behavioral, and/or timing simulations. A register transfer level (RTL)design 2415 can then be created or synthesized from the simulation model2412. The RTL design 2415 is an abstraction of the behavior of theintegrated circuit that models the flow of digital signals betweenhardware registers, including the associated logic performed using themodeled digital signals. In addition to an RTL design 2415, lower-leveldesigns at the logic level or transistor level may also be created,designed, or synthesized. Thus, the particular details of the initialdesign and simulation may vary.

The RTL design 2415 or equivalent may be further synthesized by thedesign facility into a hardware model 2420, which may be in a hardwaredescription language (HDL), or some other representation of physicaldesign data. The HDL may be further simulated or tested to verify the IPcore design. The IP core design can be stored for delivery to a 3^(rd)party fabrication facility 2465 using non-volatile memory 2440 (e.g.,hard disk, flash memory, or any non-volatile storage medium).Alternatively, the IP core design may be transmitted (e.g., via theInternet) over a wired connection 2450 or wireless connection 2460. Thefabrication facility 2465 may then fabricate an integrated circuit thatis based at least in part on the IP core design. The fabricatedintegrated circuit can be configured to perform operations in accordancewith at least one embodiment described herein.

FIG. 24B illustrates a cross-section side view of an integrated circuitpackage assembly 2470. The integrated circuit package assembly 2470illustrates an implementation of one or more processor or acceleratordevices as described herein. The package assembly 2470 includes multipleunits of hardware logic 2472, 2474 connected to a substrate 2480. Thelogic 2472, 2474 may be implemented at least partly in configurablelogic or fixed-functionality logic hardware, and can include one or moreportions of any of the processor core(s), graphics processor(s), orother accelerator devices described herein. Each unit of logic 2472,2474 can be implemented within a semiconductor die and coupled with thesubstrate 2480 via an interconnect structure 2473. The interconnectstructure 2473 may be configured to route electrical signals between thelogic 2472, 2474 and the substrate 2480, and can include interconnectssuch as, but not limited to bumps or pillars. The interconnect structure2473 may be configured to route electrical signals such as, for example,input/output (I/O) signals and/or power or ground signals associatedwith the operation of the logic 2472, 2474. Optionally, the substrate2480 may be an epoxy-based laminate substrate. The substrate 2480 mayalso include other suitable types of substrates. The package assembly2470 can be connected to other electrical devices via a packageinterconnect 2483. The package interconnect 2483 may be coupled to asurface of the substrate 2480 to route electrical signals to otherelectrical devices, such as a motherboard, other chipset, or multi-chipmodule.

The units of logic 2472, 2474 may be electrically coupled with a bridge2482 that is configured to route electrical signals between the logic2472, 2474. The bridge 2482 may be a dense interconnect structure thatprovides a route for electrical signals. The bridge 2482 may include abridge substrate composed of glass or a suitable semiconductor material.Electrical routing features can be formed on the bridge substrate toprovide a chip-to-chip connection between the logic 2472, 2474.

Although two units of logic 2472, 2474 and a bridge 2482 areillustrated, embodiments described herein may include more or fewerlogic units on one or more dies. The one or more dies may be connectedby zero or more bridges, as the bridge 2482 may be excluded when thelogic is included on a single die. Alternatively, multiple dies or unitsof logic can be connected by one or more bridges. Additionally, multiplelogic units, dies, and bridges can be connected together in otherpossible configurations, including three-dimensional configurations.

FIG. 24C illustrates a package assembly 2490 that includes multipleunits of hardware logic chiplets connected to a substrate 2480 (e.g.,base die). A graphics processing unit, parallel processor, and/orcompute accelerator as described herein can be composed from diversesilicon chiplets that are separately manufactured. In this context, achiplet is an at least partially packaged integrated circuit thatincludes distinct units of logic that can be assembled with otherchiplets into a larger package. A diverse set of chiplets with differentIP core logic can be assembled into a single device. Additionally, thechiplets can be integrated into a base die or base chiplet using activeinterposer technology. The concepts described herein enable theinterconnection and communication between the different forms of IPwithin the GPU. IP cores can be manufactured using different processtechnologies and composed during manufacturing, which avoids thecomplexity of converging multiple IPs, especially on a large SoC withseveral flavors IPs, to the same manufacturing process. Enabling the useof multiple process technologies improves the time to market andprovides a cost-effective way to create multiple product SKUs.Additionally, the disaggregated IPs are more amenable to being powergated independently, components that are not in use on a given workloadcan be powered off, reducing overall power consumption.

In various embodiments a package assembly 2490 can include fewer orgreater number of components and chiplets that are interconnected by afabric 2485 or one or more bridges 2487. The chiplets within the packageassembly 2490 may have a 2.5D arrangement usingChip-on-Wafer-on-Substrate stacking in which multiple dies are stackedside-by-side on a silicon interposer that includes through-silicon vias(TSVs) to couple the chiplets with the substrate 2480, which includeselectrical connections to the package interconnect 2483.

In one embodiment, silicon interposer is an active interposer 2489 thatincludes embedded logic in addition to TSVs. In such embodiment, thechiplets within the package assembly 2490 are arranged using 3D face toface die stacking on top of the active interposer 2489. The activeinterposer 2489 can include hardware logic for I/O 2491, cache memory2492, and other hardware logic 2493, in addition to interconnect fabric2485 and a silicon bridge 2487. The fabric 2485 enables communicationbetween the various logic chiplets 2472, 2474 and the logic 2491, 2493within the active interposer 2489. The fabric 2485 may be an NoCinterconnect or another form of packet switched fabric that switchesdata packets between components of the package assembly. For complexassemblies, the fabric 2485 may be a dedicated chiplet enablescommunication between the various hardware logic of the package assembly2490.

Bridge structures 2487 within the active interposer 2489 may be used tofacilitate a point to point interconnect between, for example, logic orI/O chiplets 2474 and memory chiplets 2475. In some implementations,bridge structures 2487 may also be embedded within the substrate 2480.

The hardware logic chiplets can include special purpose hardware logicchiplets 2472, logic or I/O chiplets 2474, and/or memory chiplets 2475.The hardware logic chiplets 2472 and logic or I/O chiplets 2474 may beimplemented at least partly in configurable logic or fixed-functionalitylogic hardware and can include one or more portions of any of theprocessor core(s), graphics processor(s), parallel processors, or otheraccelerator devices described herein. The memory chiplets 2475 can beDRAM (e.g., GDDR, HBM) memory or cache (SRAM) memory. Cache memory 2492within the active interposer 2489 (or substrate 2480) can act as aglobal cache for the package assembly 2490, part of a distributed globalcache, or as a dedicated cache for the fabric 2485

Each chiplet can be fabricated as separate semiconductor die and coupledwith a base die that is embedded within or coupled with the substrate2480. The coupling with the substrate 2480 can be performed via aninterconnect structure 2473. The interconnect structure 2473 may beconfigured to route electrical signals between the various chiplets andlogic within the substrate 2480. The interconnect structure 2473 caninclude interconnects such as, but not limited to bumps or pillars. Insome embodiments, the interconnect structure 2473 may be configured toroute electrical signals such as, for example, input/output (I/O)signals and/or power or ground signals associated with the operation ofthe logic, I/O and memory chiplets. in one embodiment, an additionalinterconnect structure couples the active interposer 2489 with thesubstrate 2480.

The substrate 2480 may be an epoxy-based laminate substrate, however, itis not limited to that and the substrate 2480 may also include othersuitable types of substrates. The package assembly 2490 can be connectedto other electrical devices via a package interconnect 2483. The packageinterconnect 2483 may be coupled to a surface of the substrate 2480 toroute electrical signals to other electrical devices, such as amotherboard, other chipset, or multi-chip module.

A logic or I/O chiplet 2474 and a memory chiplet 2475 may beelectrically coupled via a bridge 2487 that is configured to routeelectrical signals between the logic or I/O chiplet 2474 and a memorychiplet 2475. The bridge 2487 may be a dense interconnect structure thatprovides a route for electrical signals. The bridge 2487 may include abridge substrate composed of glass or a suitable semiconductor material.Electrical routing features can be formed on the bridge substrate toprovide a chip-to-chip connection between the logic or I/O chiplet 2474and a memory chiplet 2475. The bridge 2487 may also be referred to as asilicon bridge or an interconnect bridge. For example, the bridge 2487is an Embedded Multi-die Interconnect Bridge (EMIB). Alternatively, thebridge 2487 may simply be a direct connection from one chiplet toanother chiplet.

FIG. 24D illustrates a package assembly 2494 including interchangeablechiplets 2495, according to an embodiment. The interchangeable chiplets2495 can be assembled into standardized slots on one or more basechiplets 2496, 2498. The base chiplets 2496, 2498 can be coupled via abridge interconnect 2497, which can be similar to the other bridgeinterconnects described herein and may be, for example, an EMIB. Memorychiplets can also be connected to logic or I/O chiplets via a bridgeinterconnect. I/O and logic chiplets can communicate via an interconnectfabric. The base chiplets can each support one or more slots in astandardized format for one of logic or I/O or memory/cache.

SRAM and power delivery circuits may be fabricated into one or more ofthe base chiplets 2496, 2498, which can be fabricated using a differentprocess technology relative to the interchangeable chiplets 2495 thatare stacked on top of the base chiplets. For example, the base chiplets2496, 2498 can be fabricated using a larger process technology, whilethe interchangeable chiplets can be manufactured using a smaller processtechnology. One or more of the interchangeable chiplets 2495 may bememory (e.g., DRAM) chiplets. Different memory densities can be selectedfor the package assembly 2494 based on the power, and/or performancetargeted for the product that uses the package assembly 2494.Additionally, logic chiplets with a different number of type offunctional units can be selected at time of assembly based on the power,and/or performance targeted for the product. Additionally, chipletscontaining IP logic cores of differing types can be inserted into theinterchangeable chiplet slots, enabling hybrid processor designs thatcan mix and match different technology IP blocks.

Example System on a Chip Integrated Circuit

FIG. 25-26B illustrate example integrated circuits and associatedgraphics processors that may be fabricated using one or more IP cores.In addition to what is illustrated, other logic and circuits may beincluded, including additional graphics processors/cores, peripheralinterface controllers, or general-purpose processor cores. The elementsof FIG. 25-26B having the same or similar names as the elements of anyother figure herein describe the same elements as in the other figures,can operate or function in a manner similar to that, can comprise thesame components, and can be linked to other entities, as those describedelsewhere herein, but are not limited to such.

FIG. 25 is a block diagram illustrating an example system on a chipintegrated circuit 2500 that may be fabricated using one or more IPcores. Example integrated circuit 2500 includes one or more applicationprocessor(s) 2505 (e.g., CPUs), at least one graphics processor 2510,which may be a variant of the graphics processor 1408, 1508, 2510, or ofany graphics processor described herein and may be used in place of anygraphics processor described. Therefore, the discussion of any featuresin combination with a graphics processor herein also discloses acorresponding combination with the graphics processor 2510, but is notlimited to such. The integrated circuit 2500 may additionally include animage processor 2515 and/or a video processor 2520, any of which may bea modular IP core from the same or multiple different design facilities.Integrated circuit 2500 may include peripheral or bus logic including aUSB controller 2525, UART controller 2530, an SPI/SDIO controller 2535,and an PS/PC controller 2540. Additionally, the integrated circuit caninclude a display device 2545 coupled to one or more of ahigh-definition multimedia interface (HDMI) controller 2550 and a mobileindustry processor interface (MIPI) display interface 2555. Storage maybe provided by a flash memory subsystem 2560 including flash memory anda flash memory controller. Memory interface may be provided via a memorycontroller 2565 for access to SDRAM or SRAM memory devices. Someintegrated circuits additionally include an embedded security engine2570.

FIG. 26A-26B are block diagrams illustrating example graphics processorsfor use within an SoC, according to embodiments described herein. Thegraphics processors may be variants of the graphics processor 1408,1508, 2510, or any other graphics processor described herein. Thegraphics processors may be used in place of the graphics processor 1408,1508, 2510, or any other of the graphics processors described herein.Therefore, the discussion of any features in combination with thegraphics processor 1408, 1508, 2510, or any other of the graphicsprocessors described herein also discloses a corresponding combinationwith the graphics processors of FIG. 26A-26B, but is not limited tosuch. FIG. 26A illustrates an example graphics processor 2610 of asystem on a chip integrated circuit that may be fabricated using one ormore IP cores, according to an embodiment. FIG. 26B illustrates anadditional example graphics processor 2640 of a system on a chipintegrated circuit that may be fabricated using one or more IP cores,according to an embodiment. Graphics processor 2610 of FIG. 26A is anexample of a low power graphics processor core. Graphics processor 2640of FIG. 26B is an example of a higher performance graphics processorcore. For example, each of graphics processor 2610 and graphicsprocessor 2640 can be a variant of the graphics processor 2510 of FIG.25 , as mentioned at the outset of this paragraph.

As shown in FIG. 26A, graphics processor 2610 includes a vertexprocessor 2605 and one or more fragment processor(s) 2615A-2615N (e.g.,2615A, 2615B, 2615C, 2615D, through 2615N-1, and 2615N). Graphicsprocessor 2610 can execute different shader programs via separate logic,such that the vertex processor 2605 is optimized to execute operationsfor vertex shader programs, while the one or more fragment processor(s)2615A-2615N execute fragment (e.g., pixel) shading operations forfragment or pixel shader programs. The vertex processor 2605 performsthe vertex processing stage of the 3D graphics pipeline and generatesprimitives and vertex data. The fragment processor(s) 2615A-2615N usethe primitive and vertex data generated by the vertex processor 2605 toproduce a framebuffer that is displayed on a display device. Thefragment processor(s) 2615A-2615N may be optimized to execute fragmentshader programs as provided for in the OpenGL API, which may be used toperform similar operations as a pixel shader program as provided for inthe Direct 3D API.

Graphics processor 2610 additionally includes one or more memorymanagement units (MMUs) 2620A-2620B, cache(s) 2625A-2625B, and circuitinterconnect(s) 2630A-2630B. The one or more MMU(s) 2620A-2620B providefor virtual to physical address mapping for the graphics processor 2610,including for the vertex processor 2605 and/or fragment processor(s)2615A-2615N, which may reference vertex or image/texture data stored inmemory, in addition to vertex or image/texture data stored in the one ormore cache(s) 2625A-2625B. The one or more MMU(s) 2620A-2620B may besynchronized with other MMUs within the system, including one or moreMMUs associated with the one or more application processor(s) 2505,image processor 2515, and/or video processor 2520 of FIG. 25 , such thateach processor 2505-2520 can participate in a shared or unified virtualmemory system. Components of graphics processor 2610 may correspond withcomponents of other graphics processors described herein. The one ormore MMU(s) 2620A-2620B may correspond with MMU 245 of FIG. 2C. Vertexprocessor 2605 and fragment processor 2615A-2615N may correspond withgraphics multiprocessor 234. The one or more circuit interconnect(s)2630A-2630B enable graphics processor 2610 to interface with other IPcores within the SoC, either via an internal bus of the SoC or via adirect connection, according to embodiments. The one or more circuitinterconnect(s) 2630A-2630B may correspond with the data crossbar 240 ofFIG. 2C. Further correspondence may be found between analogouscomponents of the graphics processor 2610 and the various graphicsprocessor architectures described herein.

As shown FIG. 26B, graphics processor 2640 includes the one or moreMMU(s) 2620A-2620B, cache(s) 2625A-2625B, and circuit interconnect(s)2630A-2630B of the graphics processor 2610 of FIG. 26A. Graphicsprocessor 2640 includes one or more shader cores 2655A-2655N (e.g.,2655A, 2655B, 2655C, 2655D, 2655E, 2655F, through 2655N-1, and 2655N),which provides for a unified shader core architecture in which a singlecore or type or core can execute all types of programmable shader code,including shader program code to implement vertex shaders, fragmentshaders, and/or compute shaders. The exact number of shader corespresent can vary among embodiments and implementations. Additionally,graphics processor 2640 includes an inter-core task manager 2645, whichacts as a thread dispatcher to dispatch execution threads to one or moreshader cores 2655A-2655N and a tiling unit 2658 to accelerate tilingoperations for tile-based rendering, in which rendering operations for ascene are subdivided in image space, for example to exploit localspatial coherence within a scene or to optimize use of internal caches.Shader cores 2655A-2655N may correspond with, for example, graphicsmultiprocessor 234 as in FIG. 2D, or graphics multiprocessors 325, 350of FIG. 3A and 3B respectively, or multi-core group 365A of FIG. 3C.

In some embodiments, a processing resource represents a processingelement (e.g., GPGPU core, ray-tracing core, tensor core, executionresource, execution unit (EU), stream processor, streamingmultiprocessor (SM), graphics multiprocessor) associated with a graphicsprocessor or graphics processor structure (e.g., parallel processingunit, graphics processing engine, multi-core group, compute unit,compute unit of graphics core next) in a GPU as described herein. Forexample, the processing resource may be one of the GPGPU cores, ortensor/ray-tracing cores of graphics multiprocessor; a ray-tracing core,tensor core or GPGPU core of graphics multiprocessor; executionresources of graphics multiprocessor; one of GFX cores, tensor cores, orray tracing cores of a multi-core group; one of vector logic units orscalar logic units of a compute unit; execution unit with EU array or EUarray; an execution unit of execution logic; and/or execution unit. Theprocessing resource may also be an execution resource within, forexample, a graphics processing engine, processing cluster, GPGPU, GPGPU,graphics processing engine, graphics processing engine cluster, and/orgraphics processing engine. The processing resource may also be aprocessing resource within graphics processor, graphics processor,and/or graphics processor.

SoC Architecture for Low Power State Communication

Parallel computing is a type of computation in which many calculationsor the execution of processes are carried out simultaneously. Parallelcomputing may come in a variety of forms, including, but not limited to,SIMD or SIMT. SIMD describes computers with multiple processing elementsthat perform the same operation on multiple data points simultaneously.In one example, the figures discussed above refer to SIMD and itsimplementation in a general processor in terms of EUs, FPUs, and ALUs.In a common SIMD machine, data is packaged into registers, eachcontaining an array of channels. Instructions operate on the data foundin channel n of a register with the data found in the same channel ofanother register. SIMD machines are advantageous in areas where a singlesequence of instructions can be simultaneously applied to high amountsof data. For example, in one embodiment, a graphics processor (e.g.,GPGPU, GPU, etc.) can be used to perform SIMD vector operations usingcomputational shader programs.

Various embodiments can also apply to use execution by use of SingleInstruction Multiple Thread (SIMT) as an alternate to use of SIMD or inaddition to use of SIMD. Reference to a SIMD core or operation can applyalso to SIMT or apply to SIMD in combination with SIMT. The followingdescription is discussed in terms of SIMD machines. However, embodimentsherein are not solely limited to application in the SIMD context and mayapply in other parallel computing paradigms, such as SIMT, for example.For ease of discussion and explanation, the following descriptiongenerally focuses on a SIMD implementation. However, embodiments cansimilarly apply to SIMT machines with no modifications to the describedtechniques and methodologies. With respect to SIMT machines, similarpatterns as discussed below can be followed to provide instructions tothe systolic array and execute the instructions on the SIMT machine.Other types of parallel computing machines may also utilize embodimentsherein as well.

Parallel rendering graphics architectures utilize a low power state orlow power mode to save and conserve energy. During low power states,components that are high-power consuming are put into a low power state.However, any attempts to transfer data through a component in a lowpower state wake the low power state components. When trying to debug asystem in a low power state to study failures in a memory subsystem,transferring data through the low power state components, such as aprocessing resource (including an EU or sub-slices containing EUs),changes the behavior of the system and hence, cannot debug the systemappropriately.

With respect to debugging, conventional approaches for providingdebugging would transfer data through components in a low power state,such as EUs and/or sub-slices containing EUs, which would, as a result,wake up those components and put them back into a normal power state. Assuch, a debugging program that is seeking to study failures in a memorysubsystem cannot identify what the problem is in the system. This isbecause the problem occurs when the system goes into the low power stateand the debugging system is seeking to determine whether othercomponents are waking up, what is the power management, whether the pathis fine, and so on.

Embodiments herein address the above-noted technical problems byproviding an SoC architecture for low power state communication.Implementations provide a low power agent a memory bridge fabric agent,and a dedicated fabric path that bypasses the processing resources,where the architecture sends tuned transactions through various channelsto the memory.

Embodiments provide a technical advantage of improving resourceutilization by improving power consumption through avoiding waking upprocessing resources during a low power state mode. Implementationsherein further improve the debugging program by allowing the program toaccurately identify issues occurring during a low power state. Withoutthis infrastructure, the debugging program is not able to decipher whereproblems occur when processing resources, such as EUs, go into low powerstates.

FIG. 27 is a block diagram illustrating an example SoC 2700 implementingan architecture for low power state communication, according toembodiments herein. In one embodiment, SoC 2700 may be the same as SoC2500 described with respect to FIG. 25 , for example. In one embodiment,SoC 2700 may include a GPGPU or GPU, such as the example GPGPUs and/orGPUs described herein with respect to FIGS. 1-26 . The elements of FIG.27 having the same or similar names as the elements of any other figureherein describe the same elements as in the other figures, can operateor function in a manner similar to that, can comprise the samecomponents, and can be linked to other entities, as those describedelsewhere herein, but are not limited to such.

Example SoC 2700 may include processing resources 2750, which may bepart of a graphics processor, such as any variant of the graphicsprocessor 1408 of FIG. 14 , graphics processor 1508 of FIG. 15 ,graphics processor 2510 of FIG. 25 , or of any graphics processordescribed herein and may be used in place of any graphics processordescribed. Example processing resources 2750 may be a variant of theexecution unit 1900 or of any execution unit or processing resourcedescribed herein and may be used in place of any execution resourcedescribed. Therefore, the discussion of any features in combination witha graphics processor herein also discloses a corresponding combinationwith the SoC 2700, but is not limited to such.

The SoC 2700 illustrated in FIG. 27 may include one or more processingresources 2750. In some embodiment, processing resources 2750 may alsobe referred to herein as execution resources. The processing resource2750 may be a compute-optimized processing resources, such as an EU, foruse in, for example, a compute engine tile 1640A-1640D as in FIG. 16C,but is not limited as such. The processing resource 2750 may also beused in a graphics engine tile 1610A-1610D as in FIG. 16B.

The SoC 2700 may include, but is not limited to, a root port 2701, aPCIe PHY 2703, a CXL/PCIe upstream port (USP) 2704, an interconnectbridge 2706 (e.g., IoSF bridge), a primary scalable fabric (PSF)-0 2710,a PSF-1 2711, a PSF-2 2712, a PSF-3 2713, a power management controller2715, a memory bridge fabric agent 2730, a low power state agent 2720,video signal processor (VSP)0 2740, VSP12741, VSP22742, a server manager(SM) 2744, Audio 2743, send gather unit (SGUnit) 2745, processingresources 2750, memory bridge 2762, memory controller devices 2764, andmemory 2760. The components of SoC 2700 may be communicably coupled toone another for communications purposes uses fabric components, such asrouters, multiplexors, switches, crossbar switches, and so on. In oneimplementations, the fabric components may be part of an interconnectfabric, such as interconnect fabric 327 of FIG. 3A or interconnectfabric 2485 of FIG. 24 , for example. In one embodiment, PSF-0 2710,PSF-1 2711, PSF-2 2712, and PSF-3 2713 (collectively referred to hereinPSF) provide an integrated on-chip scalable fabric (interconnectfabric), which may be designed according to a given specificationprovided by a semiconductor manufacturer to provide a standardizedon-die interconnect protocol for attaching intellectual property (IP)blocks within a chip, such as SoC 2700. In one implementation, a CPUinterface may couple to the fabric provides by PSFs 2710-2713 via a rootport 2701 of SoC 2700.

In embodiments herein, SoC 2700 implements an architecture for low powerstate communications. During a regular power state of the SoC 2700,transaction following the regular power state path 2702 through the SoC2700 to transfer data in and out of memory 2760. If the SoC is in a lowpower state, usage of the regular power state path 2702 would cause theprocessing resources 2750 to be woken up and no longer be in a low powerstate, causing the above-noted drawbacks such as difficulty debugging inthe low power state.

To address such technical problems, the SoC 2700 architecture for lowpower state communication utilizes a low power state agent 2720 thatsends tuned transactions (e.g., originating from MS 2744, audio 2743,etc.) through various channels to the memory 2760. Embodiments hereinutilize three features of SoC 2700 architecture to enable low powerstate communications. The three features include (1) the low power stateagent 2720, (2) the low power state path 2705 through the interconnectfabric, including PSFs 2710-2713, and (3) the memory bridge fabricagent.

Embodiments of the SoC 2700 architecture for low power statecommunications include an alternate low power state path 2705 that isconfigured in portions of the interconnect fabric (e.g., PSFs 2710-2713)of SoC 2700 to cause transactions to travel through the interconnectfabric while avoiding the processing resources 2750. This separatealternate low power state path 2705 is utilized to transfer data in andout of memory 2760 during the low power state, without waking up theprocessing resources 2750.

As illustrated, the low power state path 2705 used during low powerstate of the SoC 2700 is different than the regular power state path2702 used during normal operational mode of the SoC. The low power statepath 2705 travels through a memory bridge fabric agent 2730 that canconvert the associated traffic into s language the memory bridge 2762(and associated memory controller devices 2764 and memory 2760)understands. Further details of the low power state agent 2720 and thememory bridge fabric agent 2730 are provided further below with respectto FIGS. 28 and 30 , respectively.

FIG. 28 is a block diagram of a SoC architecture 2800 having a low powerstate agent 2805 in communication with a PSF 2860, according toembodiments herein. In one embodiment, low power state agent 2805 is thesame as low power state agent 2720 described with respect to FIG. 27 andPSF 2860 is the same as PSF-1 2711 described with respect to FIG. 27 .Low power state agent 2805 may include a set of hardware, software,firmware elements and/or any combination of hardware, software and/orfirmware elements. In some embodiments, low power state agent 2805 isreferred to a low power state agent circuitry, in reference to thehardware circuitry utilized to implement low power state agent 2805.Similarly, PSF 2860 may include a collection of communication hardwareelements to implement an interconnect fabric, such as switches, crossbarswitches, multiplexors, routers, etc.

The low power state agent 2805 is a programmable agent that is used toreceive and send transactions (also referred to herein as “traffic” or“communications”) during a low power state of the SoC architecture 2800.The low power state agent 2805 can access any path, bank, row, etc. ofmemory (e.g., memory 2760 of FIG. 27 ). In one example, low power stateagent 2805 can send transactions at 6.4 GB/s and is equipped to support,for example 64-byte cache line reads and writes.

As shown in FIG. 28 , low power state agent 2805 includes a maininterface 2801 and a target interface 2802. The target interface 2802includes a target interface (intf.) finite state machine (FSM) 2835,data and command multiple input signature registers (MISRs) 2850, and asimple task actor protocol (STAP) interface 2855. These components 2835,2850, 2855 are programmed to work in conjunction with one another toreceive transactions at the low power state agent 2805 during low powerstate of the SoC architecture 2800. The main interface 2801 includes aservice telemetry framework (STF) network interface 2810, sidebandendpoint 2845, FIFO queue 2815, register blocks 2825, FIFO unload logic2820, a main interface FSM 2830, and an infinite state machine (ISM)2840. These components 2810, 2845, 2815, 2825, 2820, 2830, 2840 areprogrammed to work in conjunction with one another to send transactionsto the PSF 2860 during a low power state of the SoC architecture 2800.

The low power state agent 2805 is capable of sending cache linetransactions, or can access any rows of interest, any columns ofinterest, etc. without waking up and/or taking traffic through the EUs.The transactions at the low power state agent 2805 can go throughhashing in order to support virtual to physical address mapping. The lowpower state agent 2805 can further utilize the components of the maininterface 2801 to send cache line transactions in bursts. The low powerstate agent 2805 can also use checks, such as parity checks, to detectcorruption in individual sectors of the overall memory.

In embodiments herein, the low power state agent 2805 can communicatewith an SoC power controller (e.g., power management controller 2715 ofFIG. 27 ) to clear the alternate low power state path (e.g., low powerstate path 2705 of FIG. 27 ) as part of entry into the low power statemode. The low power state agent 2805 can also program fabric routers(e.g., routers of PSFs 2710-2713 (including PSF 2860)) to enable thetransactions to route into the memory controller through an alternativepath that avoids the processing resources (e.g., processing resources2750 of FIG. 27 ) of the SoC architecture 2800. Furthermore, low powerstate agent 2805 communicates with one or more memory controller devices(such as memory controller devices 2764) to ensure a reliable path tothe memory (e.g., memory 2760 of FIG. 27 ) before the SoC architecture2800 enters the low power state. The low power state agent 2805 can alsosupport parity generation and checking to allow for robust and errorfree transaction communication. FIG. 29 below further details the abovecapabilities of the low power state agent 2805.

FIG. 29 is a schematic 2900 illustrating implementation of low powerstate communications in an SoC architecture, in accordance withembodiments herein. Schematic 2900 details operations of components ofan SoC architecture, such as SoC 2700 described with respect to FIG. 27and/or SoC architecture 2800 described with respect to FIG. 28 .Schematic 2900 illustrates an example operational flow between an SoCpower management controller 2901 (such as power management controller2715 of FIG. 27 ), low power state agent 2902 (such as low power stateagent 2720 of FIG. 27 or low power state agent 2805 of FIG. 28 ), fabricrouter 2903 (such as PSFs 2710-2713 of FIG. 27 ), address mapping 2904(such as hashing tables included in a low power state agent 2720, 2805of FIGS. 27-28 ), and a memory controller 2905 (such as memorycontroller devices 2764 of FIG. 27 ).

At 2910, SoC power management controller 2901 sends a mailboxcommunication to the low power state agent 2902 informing of the powermanagement controller's 2901 intent to take the SoC into a low powerstate. In one embodiment, larger power consuming components (e.g.,processing resources, rendering engine, micro-controller, etc.) are tobe placed into the low power states. This means that other agents in theSoC and the host controller cannot route their communications to thememory controller 2905 through these agents that were put into low powerstates.

At 2915, the low power state agent 2902 programs the fabric routers 2903to re-route communications through an alternative path, such as lowpower state path 2705 described with respect to FIG. 27 . At 2920, thelow power state agent 2902 programs the address mapping 2904 components(e.g., hashing tables etc.) to translate the SoC logic address to thelocal memory device physical address. This enables the communications ofthe SoC agents to go through the configured low power state path (e.g.,low power state path 2705 of FIG. 27 ). At 2925, the low power stateagent 2902 enables parity generation and checking to allow for reliableand correct utilization of the configured low power state path. At 2930,the memory controller 2905 responds with a confirmation that thealternate low power state path is working correctly.

At 2935, the low power state agent 2902 hands control back to the SoCpower management controller 2901 with a mailbox handshake mechanism. Inresponse, the SoC power management controller 2901 enters the SoC into alow power state mode at 2940.

When the times comes to exit the low power state mode and re-enter intoa normal power operational mode at 2945, the SoC power managementcontroller 2901 sends a mailbox communication to the low power stateagent 2902 to inform of the intent to exit the SoC low power state. At2950, the low power state agent 2902 programs the fabric routers 2903 toroute transaction traffic through the mainstream agents (e.g.,processing resources, rendering engine, micro-controller, etc.). At2955, the fabric routers 2903 configure the memory controller 2905arbiters to prevent the bypass communication through the low power statepath. At 2960, the low power state agent 2902 hands control back to theSoC power management controller 2901. The low power state mode is thenexited at 2965.

FIG. 30 is a block diagram of a SoC architecture 3000 having a low powerstate agent 3002 in communication with a memory bridge fabric agent3010, which is in communication with a memory controller 3004, inaccordance with embodiments herein. In one embodiment, low power stateagent 3002 is the same as low power state agent 2720 described withrespect to FIG. 27 and low power state agent 2805 described with respectto FIG. 28 . Memory bridge fabric agent 3010 may be the same as memorybridge fabric agent 2730 described with respect to FIG. 27 . Memorycontroller 3004 may be the same as memory controller devices 2764described with respect to FIG. 27 . and PSF 2860 is the same as PSF-12711 described with respect to FIG. 27 .

In one embodiment, memory bridge fabric agent 3010 may include a set ofhardware, software, firmware elements and/or any combination ofhardware, software and/or firmware elements. In some embodiments, memorybridge fabric agent 3010 is referred to memory bridge fabric agentcircuitry, in reference to the hardware circuitry utilized to implementmemory bridge fabric agent 3010.

In one embodiment, memory bridge fabric agent 3010 is referred to as amemory bridge port, such as an IoSF to CMI bridge port. The memorybridge fabric agent 3010 can convert received transaction traffic into alanguage that the memory bridge and memory controller 3004 canunderstand. Once the transaction is converted, the memory bridge fabricagent 3010 can route the transaction to the final memory controller3004.

As illustrated in FIG. 30 , the memory bridge fabric agent 3010 mayinclude a variety of components to implement the conversion and routingoperations of the memory bridge fabric agent 3010. As shown in theexample of SoC architecture 3000 of FIG. 30 , memory bridge fabric agent3010 converts IoSF to Advanced eXtensible Interface (AXI), and viceversa. However, other communication protocols may be implemented andconverted by memory bridge fabric agent 3010 and implementations hereinare not limited to the particular protocols illustrated in FIG. 30 .

In one embodiment, memory bridge fabric agent 3010 includes, forexample, an IOSF target interface 3011, an IOSF main interface 3012,security attribute converters 1-2 3040-3045, private configurationregisters 3015, IOSF Sideband handler 3020, incoming command and dataqueues 3030, outgoing command and data queues 3035, AXI primarytransaction layer 3050, and AXI secondary transaction layer 3055.

The IOSF Main 3012 and Target 3011 Interfaces handle the IoSF protocollayer and provides an internal interface for the rest of the componentsof the memory bridge fabric agent 3010. The IOSF sideband handler 3020provides sideband connectivity for the IOSF to AXI conversionoperations. IOSF sideband handler 3020 is used for accessing privateconfiguration registers 3015, as well as any other the MMIO region belowthe AXI primary interface. The IOSF sideband handler 3020 may include anIOSF sideband endpoint, and a module that converts the IRDY/TRDYprotocol from the Sideband endpoint module to a parallel interfacebringing out all the sideband attributes.

The AXI primary 3050 and secondary 3055 Interfaces provide connectivityto AXI Interconnect or AXI IPs below the Bridge. Both the primary andsecondary interfaces can be made of 5 channels, as utilized by the AXIProtocol.

The private configuration registers 3015 may include IOSF to AXIspecific control and status registers. In one embodiment, theseregisters 3015 can be accessed using the IOSF sideband handler 3020.

Incoming command and data queues 3030 and outgoing command and dataqueues 3035 may include data structures to store non-posted and postedcommands and data. Queues 3030, 3035, may also store CPL Data, which isdata returned as a part of the read command are stored into these queues3030, 3035.

The security attributes of the IOSF and the AXI protocols are differentand, hence utilize the security attribute converters 3040, 3045. Theconverters 3040, 3045 convert IOSF security attributes into AXI securityattributes and from AXI security attributes to IOSF security attributes.The security attribute converter 1 3040 can handle DS requests and UScompletions, while the security attribute converter 2 3045 can handle USrequests and DS Completions.

FIG. 31 is a flow diagram illustrating an embodiment of a method 3100for implementing an SoC architecture for low power state communication.Method 3100 may be performed by processing logic that may comprisehardware (e.g., circuitry, dedicated logic, programmable logic, etc.),software (such as instructions run on a processing device), or acombination thereof. The process of method 3100 is illustrated in linearsequences for brevity and clarity in presentation; however, it iscontemplated that any number of them can be performed in parallel,asynchronously, or in different orders. Further, for brevity, clarity,and ease of understanding, many of the components and processesdescribed with respect to FIGS. 1-30 may not be repeated or discussedhereafter. In one implementation, low power state agent circuitry, suchas low power state agent 2720 of FIG. 27 or low power state agent 2805of FIG. 28 , may perform method 3100.

Method 3100 begins at processing block 3110 where the low power stateagent circuitry may determine that a low power state entry process isinitiated in an apparatus. In one embodiment, the apparatus is an SoC.Then, at block 3120, the low power state agent circuitry may update, inresponse to initiation of the low power state in the apparatus, aconfiguration of routers of the apparatus to utilize a low power statepath provided by a low power state fabric. In one implementation, thelow power state path to avoid compute processing resources of theapparatus.

Subsequently, at block 3130, the low power state agent circuitry mayprogram hashing tables to translate logical addresses to a local memorydevice physical address. Lastly, at block 3140, the low power stateagent circuitry may, responsive to the apparatus operating in the lowpower state, route, using the programmed hashing tables, memorytransactions via the low power state path to one or more memory devices.

FIG. 32 is a flow diagram illustrating an embodiment of a method 3200for entering a low power state and communicating in the low power stateusing an alternate low power state fabric path. Method 3200 may beperformed by processing logic that may comprise hardware (e.g.,circuitry, dedicated logic, programmable logic, etc.), software (such asinstructions run on a processing device), or a combination thereof. Theprocess of method 3200 is illustrated in linear sequences for brevityand clarity in presentation; however, it is contemplated that any numberof them can be performed in parallel, asynchronously, or in differentorders. Further, for brevity, clarity, and ease of understanding, manyof the components and processes described with respect to FIGS. 1-31 maynot be repeated or discussed hereafter. In one implementation, an SoC,such as SoC 2700 of FIG. 27 , may perform method 3200.

Method 3200 begins at processing block 3210 where the SoC may receivemailbox communication from power management controller indicatinginitiation of low power state entry process. Then, at block 3220, theSoC may program fabric routers to re-route transaction communicationsthrough a low power state path of a low power state fabric, the lowpower state path to avoid compute processing resources. At block 3230,the SoC may program hash tables to translate logical addresses to thelocal memory device physical address.

Subsequently, at block 3240, the SoC may enable parity generation andchecking to determine that the low power state path is workingcorrectly. Then, at block 3250, the SoC may hand control back to thepower management controller with mailbox handshake, the power managementcontroller to cause entry to the low power state. Lastly, at block 3260,the SoC may route transaction communications to a memory bridge fabricagent via the low power state path, the memory bridge fabric agent toconvert the transaction communications from a first communicationprotocol to a second communication protocol of a memory device.

FIG. 33 is a flow diagram illustrating an embodiment of a method 3300for exiting a low power state in an SoC architecture for low power statecommunications. Method 3300 may be performed by processing logic thatmay comprise hardware (e.g., circuitry, dedicated logic, programmablelogic, etc.), software (such as instructions run on a processingdevice), or a combination thereof. The process of method 3300 isillustrated in linear sequences for brevity and clarity in presentation;however, it is contemplated that any number of them can be performed inparallel, asynchronously, or in different orders. Further, for brevity,clarity, and ease of understanding, many of the components and processesdescribed with respect to FIGS. 1-32 may not be repeated or discussedhereafter. In one implementation, an SoC, such as SoC 2700 of FIG. 27 ,may perform method 3300.

Method 3300 begins at processing block 3310 where the SoC may receivemailbox communication from power management controller indicatinginitiation of low power state exit process. Then, at block 3320, the SoCmay program fabric routers to re-route transaction communication throughmainstream agents in a normal power state path through computeprocessing resources. Lastly, at block 3330, the SoC may hand controlback to the power management controller with mailbox handshake, thepower management controller to cause exit from the low power state.

The following examples pertain to further embodiments. Example 1 is anapparatus to facilitate a system-on-a-chip (SoC) architecture for lowpower state communication. The apparatus of Example 1 includes a lowpower state fabric to provide a low power state path that avoids computeprocessing resources of the apparatus; and a low power state agentcircuitry communicably coupled to the low power state fabric to: update,in response to initiation of a low power state in the apparatus, aconfiguration of routers of the low power state fabric to utilize thelow power state path provided by the low power state fabric; and routememory transactions to the low power state path while the apparatus isin the low power state.

In Example 2, the subject matter of Example 1 can optionally includefurther comprising a power management controller to send a mailboxcommunication to the low power state agent circuitry to cause initiationof the low power state. In Example 3, the subject matter of any one ofExamples 1-2 can optionally include wherein the low power state agentcircuitry is further to program hashing tables to translate logicaladdresses to a local memory device physical address for the memorytransactions. In Example 4, the subject matter of any one of Examples1-3 can optionally include wherein the low power state agent circuitryto determine that the low power state path is operating reliably byimplementing a parity check.

In Example 5, the subject matter of any one of Examples 1-4 canoptionally include wherein the low power state agent circuitry to routethe memory transactions further comprising transmitting cache linetransactions in bursts and collecting data. In Example 6, the subjectmatter of any one of Examples 1-5 can optionally include furthercomprising a memory bridge fabric agent circuitry to convert thetransactions from a first communication protocol of the low power agentcircuitry to a second communication protocol of a memory device of theapparatus. In Example 7, the subject matter of any one of Examples 1-6can optionally include wherein the first communication protocolcomprises Intel On-Chip System Fabric (IOSF) communication protocol andwherein the second communication protocol comprises Advanced eXtensibleInterface (AXI) communication protocol.

In Example 8, the subject matter of any one of Examples 1-7 canoptionally include wherein the memory bridge fabric agent circuitry isto implement parity checks with a memory device that receives thetransactions. In Example 9, the subject matter of any one of Examples1-8 can optionally include wherein the apparatus comprising asystem-on-a-chip (SoC) comprising a graphics processing unit (GPU). InExample 10, the subject matter of any one of Examples 1-9 can optionallyinclude wherein the GPU is at least one of a single instruction multipledata (SIMD) machine or a single instruction multiple thread (SIMT)machine.

Example 11 is a method for facilitating a system-on-a-chip (SoC)architecture for low power state communication. The method of Example 11can include updating, by low power state agent circuitry of an apparatusin response to initiation of a low power state in the apparatus, aconfiguration of routers of a low power state fabric to utilize a lowpower state path provided by the low power state fabric, the low powerstate path to avoid compute processing resources of the apparatus;programming, by the low power state agent circuitry, hashing tables totranslate logical addresses to a local memory device physical address;and responsive to the apparatus operating in the low power state,routing, by the low power state agent circuitry using the programmedhashing tables, memory transactions via the low power state path to oneor more memory devices.

In Example 12, the subject matter of Example 11 can optionally includewherein the low power state agent circuitry further to program hashingtables to translate logical addresses to a local memory device physicaladdress for the memory transactions. In Example 13, the subject matterof Examples 11-12 can optionally include wherein the low power stateagent circuitry to determine that the low power state path is operatingreliably by implementing a parity check.

In Example 14, the subject matter of Examples 11-13 can optionallyinclude wherein the low power state agent circuitry to route the memorytransactions further comprising transmitting cache line transactions inbursts and collecting data. In Example 15, the subject matter ofExamples 11-14 can optionally include further comprising a memory bridgefabric agent circuitry to convert the transactions from a firstcommunication protocol of the low power agent circuitry to a secondcommunication protocol of a memory device of the apparatus.

Example 16 is a system for facilitating a system-on-a-chip (SoC)architecture for low power state communication. The system of Example 16can optionally include a memory to store a block of data; a processorcoupled to the memory, the processor comprising processing resource; alow power state fabric communicably coupled to the memory, the low powerstate fabric to provide a low power state path that avoids theprocessing resources of the processor; and a low power state agentcircuitry communicably coupled to the low power state fabric and to thememory, the low power state agent circuitry to: update, in response toinitiation of a low power state in the system, a configuration ofrouters of the low power state fabric to utilize the low power statepath provided by the low power state fabric; and route memorytransactions to the low power state path while the apparatus is in thelow power state.

In Example 17, the subject matter of Example 16 can optionally includewherein the low power state agent circuitry is further to programhashing tables to translate logical addresses to a local memory devicephysical address for the memory transactions. In Example 18, the subjectmatter of Examples 16-17 can optionally include wherein the low powerstate agent circuitry to determine that the low power state path isoperating reliably by implementing a parity check.

In Example 19, the subject matter of Examples 16-18 can optionallyinclude wherein the low power state agent circuitry to route the memorytransactions further comprising transmitting cache line transactions inbursts and collecting data. In Example 20, the subject matter ofExamples 16-19 can optionally include further comprising a memory bridgefabric agent circuitry to convert the transactions from a firstcommunication protocol of the low power agent circuitry to a secondcommunication protocol of a memory device of the apparatus.

Example 21 is a non-transitory computer-readable storage medium forfacilitating a system-on-a-chip (SoC) architecture for low power statecommunication. The non-transitory computer-readable storage medium ofExample 21 having stored thereon executable computer programinstructions that, when executed by one or more processors, cause theone or more processors to perform operations comprising: updating, bylow power state agent circuitry of an apparatus in response toinitiation of a low power state in the apparatus, a configuration ofrouters of a low power state fabric to utilize a low power state pathprovided by the low power state fabric, the low power state path toavoid compute processing resources of the apparatus; programming, by thelow power state agent circuitry, hashing tables to translate logicaladdresses to a local memory device physical address; and responsive tothe apparatus operating in the low power state, routing, by the lowpower state agent circuitry using the programmed hashing tables, memorytransactions via the low power state path to one or more memory devices.

In Example 22, the subject matter of Example 21 can optionally includewherein the low power state agent circuitry further to program hashingtables to translate logical addresses to a local memory device physicaladdress for the memory transactions. In Example 23, the subject matterof Examples 21-22 can optionally include wherein the low power stateagent circuitry to determine that the low power state path is operatingreliably by implementing a parity check.

In Example 24, the subject matter of Examples 21-23 can optionallyinclude wherein the low power state agent circuitry to route the memorytransactions further comprising transmitting cache line transactions inbursts and collecting data. In Example 25, the subject matter ofExamples 21-24 can optionally include further comprising a memory bridgefabric agent circuitry to convert the transactions from a firstcommunication protocol of the low power agent circuitry to a secondcommunication protocol of a memory device of the apparatus.

Example 26 is an apparatus for facilitating a system-on-a-chip (SoC)architecture for low power state communication comprising means forupdating, via low power state agent circuitry of an apparatus inresponse to initiation of a low power state in the apparatus, aconfiguration of routers of a low power state fabric to utilize a lowpower state path provided by the low power state fabric, the low powerstate path to avoid compute processing resources of the apparatus; meansfor programming, via the low power state agent circuitry, hashing tablesto translate logical addresses to a local memory device physicaladdress; and responsive to the apparatus operating in the low powerstate, means for routing, via the low power state agent circuitry usingthe programmed hashing tables, memory transactions via the low powerstate path to one or more memory devices. In Example 27, the subjectmatter of Example 26 can optionally include the apparatus furtherconfigured to perform the method of any one of the Examples 12 to 15.

Example 28 is at least one machine readable medium comprising aplurality of instructions that in response to being executed on acomputing device, cause the computing device to carry out a methodaccording to any one of Examples 11-15. Example 29 is an apparatus forfacilitating a system-on-a-chip (SoC) architecture for low power statecommunication, configured to perform the method of any one of Examples11-15. Example 30 is an apparatus for facilitating a system-on-a-chip(SoC) architecture for low power state communication, comprising meansfor performing the method of any one of claims 10 to 15. Specifics inthe Examples may be used anywhere in one or more embodiments.

The foregoing description and drawings are to be regarded in anillustrative rather than a restrictive sense. Persons skilled in the artcan understand that various modifications and changes may be made to theembodiments described herein without departing from the broader spiritand scope of the features set forth in the appended claims.

What is claimed is:
 1. An apparatus comprising: a low power state fabricto provide a low power state path that avoids compute processingresources of the apparatus; and a low power state agent circuitrycommunicably coupled to the low power state fabric to: update, inresponse to initiation of a low power state in the apparatus, aconfiguration of routers of the low power state fabric to utilize thelow power state path provided by the low power state fabric; and routememory transactions to the low power state path while the apparatus isin the low power state.
 2. The apparatus of claim 1, further comprisinga power management controller to send a mailbox communication to the lowpower state agent circuitry to cause initiation of the low power state.3. The apparatus of claim 1, wherein the low power state agent circuitryis further to program hashing tables to translate logical addresses to alocal memory device physical address for the memory transactions.
 4. Theapparatus of claim 1, wherein the low power state agent circuitry todetermine that the low power state path is operating reliably byimplementing a parity check.
 5. The apparatus of claim 1, wherein thelow power state agent circuitry to route the memory transactions furthercomprising transmitting cache line transactions in bursts and collectingdata.
 6. The apparatus of claim 1, further comprising a memory bridgefabric agent circuitry to convert the transactions from a firstcommunication protocol of the low power agent circuitry to a secondcommunication protocol of a memory device of the apparatus.
 7. Theapparatus of claim 6, wherein the first communication protocol comprisesIntel On-Chip System Fabric (IOSF) communication protocol and whereinthe second communication protocol comprises Advanced eXtensibleInterface (AXI) communication protocol.
 8. The apparatus of claim 6,wherein the memory bridge fabric agent circuitry is to implement paritychecks with a memory device that receives the transactions.
 9. Theapparatus of claim 1, wherein the apparatus comprising asystem-on-a-chip (SoC) comprising a graphics processing unit (GPU). 10.The apparatus of claim 8, wherein the GPU is at least one of a singleinstruction multiple data (SIMD) machine or a single instructionmultiple thread (SIMT) machine.
 11. A method comprising: updating, bylow power state agent circuitry of an apparatus in response toinitiation of a low power state in the apparatus, a configuration ofrouters of a low power state fabric to utilize a low power state pathprovided by the low power state fabric, the low power state path toavoid compute processing resources of the apparatus; programming, by thelow power state agent circuitry, hashing tables to translate logicaladdresses to a local memory device physical address; and responsive tothe apparatus operating in the low power state, routing, by the lowpower state agent circuitry using the programmed hashing tables, memorytransactions via the low power state path to one or more memory devices.12. The method of claim 11, wherein the low power state agent circuitryfurther to program hashing tables to translate logical addresses to alocal memory device physical address for the memory transactions. 13.The method of claim 11, wherein the low power state agent circuitry todetermine that the low power state path is operating reliably byimplementing a parity check.
 14. The method of claim 11, wherein the lowpower state agent circuitry to route the memory transactions furthercomprising transmitting cache line transactions in bursts and collectingdata.
 15. The method of claim 11, further comprising a memory bridgefabric agent circuitry to convert the transactions from a firstcommunication protocol of the low power agent circuitry to a secondcommunication protocol of a memory device of the apparatus.
 16. A systemcomprising: a memory to store a block of data; a processor coupled tothe memory, the processor comprising processing resource; a low powerstate fabric communicably coupled to the memory, the low power statefabric to provide a low power state path that avoids the processingresources of the processor; and a low power state agent circuitrycommunicably coupled to the low power state fabric and to the memory,the low power state agent circuitry to: update, in response toinitiation of a low power state in the system, a configuration ofrouters of the low power state fabric to utilize the low power statepath provided by the low power state fabric; and route memorytransactions to the low power state path while the apparatus is in thelow power state.
 17. The system of claim 16, wherein the low power stateagent circuitry is further to program hashing tables to translatelogical addresses to a local memory device physical address for thememory transactions.
 18. The system of claim 16, wherein the low powerstate agent circuitry to determine that the low power state path isoperating reliably by implementing a parity check.
 19. The system ofclaim 16, wherein the low power state agent circuitry to route thememory transactions further comprising transmitting cache linetransactions in bursts and collecting data.
 20. The system of claim 16,further comprising a memory bridge fabric agent circuitry to convert thetransactions from a first communication protocol of the low power agentcircuitry to a second communication protocol of a memory device of theapparatus.